Esempio n. 1
0
        public async Task <string> Post(Want want)
        {
            var fb             = this.data.GetFacebookInfo();
            var facebookClient = new Facebook.FacebookClient(fb.AccessToken);

            var postParams = new
            {
                name        = string.Format("In Search Of: {0}", want.Title),
                caption     = string.Format("Can anyone help me find: '{0}'?", want.Title),
                description = want.Description,
                link        = string.Format("http://www.borentra.com/wanted/{0}", want.Key),
                picture     = want.LargeImage,
            };

            string shareMessage = null;

            try
            {
                await facebookClient.PostTaskAsync("/me/feed", postParams);

                shareMessage = string.Format("Successfully shared: '{0}'.", want.Title);
            }
            catch (Exception ex)
            {
                shareMessage = string.Format("Unable to post at this time: '{0}'", ex.Message);
            }

            return(shareMessage);
        }
Esempio n. 2
0
        public async Task DeleteWantAndPushToDbAsync(Want model)
        {
            Want want = await _itemFetcherService.GetSpecificWantAsync(model.Id);

            _db.Wants.Remove(want);
            await _db.SaveChangesAsync();
        }
        public async Task <IActionResult> Edit(int id, [Bind("Name,Price")] Want want)
        {
            if (id != want.id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
                    if (want.OwnerId != userId)
                    {
                        return(NoContent());
                    }
                    _context.Update(want);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WantExists(want.id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(want));
        }
Esempio n. 4
0
        private async void PublishStory(Want want)
        {
            await this.loginButton.RequestNewPermissions("publish_stream");

            var shareMessage = await this.facebook.Post(want);

            var diag = new MessageDialog(shareMessage);
            await diag.ShowAsync();
        }
Esempio n. 5
0
        private void WantCreated(object sender, Want want)
        {
            this.flyout.Hide();

            var items = this.DefaultViewModel["Items"] as IList <Want>;

            this.DefaultViewModel["Items"] = null;
            items.Add(want);
            this.DefaultViewModel["Items"] = items;
        }
Esempio n. 6
0
        public async Task EditWantAndPushToDbAsync(EditViewModel model)
        {
            Want want = await _itemFetcherService.GetSpecificWantAsync(model.Id);

            want.Name   = model.Name;
            want.Amount = model.Amount;

            _db.Wants.Update(want);
            await _db.SaveChangesAsync();
        }
Esempio n. 7
0
        public IHttpActionResult My(string token)
        {
            if (auth.IsNotValid(token))
            {
                return(base.StatusCode(System.Net.HttpStatusCode.Unauthorized));
            }

            var callerId = auth.Device.UserIdentifier;
            var requests = this.wantCore.Search(callerId, callerId);
            var wants    = requests.Select(r => Want.Map(r));

            return(this.Ok <IEnumerable <Want> >(wants));
        }
        public async Task <IActionResult> Create([Bind("Name,Price")] Want want)
        {
            if (ModelState.IsValid)
            {
                var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
                want.OwnerId = userId;
                _context.Add(want);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(want));
        }
Esempio n. 9
0
        public async Task CreateWantAndPushToDbAsync(AddViewModel model)
        {
            Want want = new Want()
            {
                Name        = model.Name,
                Amount      = model.Amount,
                User        = _user,
                DateCreated = DateTime.Now
            };

            await _db.Wants.AddAsync(want);

            await _db.SaveChangesAsync();
        }
        public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
        {
            if (Have.Count() != Want.Count())
            {
                yield break;
            }

            if (Have.All(i => Want.Any(j => j.Id == i.Id)) &&
                Want.All(i => Have.Any(j => j.Id == i.Id)))
            {
                yield return(new ValidationResult(
                                 "It is not possible to create a trade for the same items.", new[] { "Have", "Want" }));
            }
        }
Esempio n. 11
0
        public async Task <EditViewModel> CreateNeededModelForEditWants(int Id)
        {
            Want want = await _itemFetcherService.GetSpecificWantAsync(Id);

            var model = new EditViewModel()
            {
                Id             = want.Id,
                Name           = want.Name,
                Amount         = want.Amount,
                PreviousAmount = want.Amount,
                DateCreated    = want.DateCreated
            };

            return(model);
        }
Esempio n. 12
0
        public IHttpActionResult Save(SecuredWant want)
        {
            if (auth.IsNotValid(want))
            {
                return(base.StatusCode(System.Net.HttpStatusCode.Unauthorized));
            }

            if (null == want)
            {
                return(this.BadRequest("want"));
            }

            if (want.Delete && Guid.Empty == want.Identifier)
            {
                return(this.BadRequest("delete must have identifier"));
            }

            if (Guid.Empty == want.Identifier)
            {
                want.Identifier = Guid.NewGuid();
            }
            if (!string.IsNullOrWhiteSpace(want.ImageUrl))
            {
                try
                {
                    this.SaveImagebyUrl(this.auth.Device.UserIdentifier, want.Identifier, want.ImageUrl);
                }
                catch { }
            }
            want.UserIdentifier = auth.Device.UserIdentifier;

            var itemRequest = this.wantCore.Save(want);

            if (null != itemRequest)
            {
                var result = Want.Map(itemRequest);
                return(this.Ok <Want>(result));
            }
            else
            {
                return(this.Ok());
            }
        }
Esempio n. 13
0
        public IHttpActionResult Get(string key, string token = null)
        {
            var authorized = auth.IsNotValid(token);

            if (string.IsNullOrWhiteSpace(key))
            {
                return(this.BadRequest("key"));
            }

            key = key.TrimIfNotNull();

            var callerId    = authorized ? auth.Device.UserIdentifier : (Guid?)null;
            var itemRequest = this.wantCore.Get(key, null, callerId);

            if (null != itemRequest)
            {
                var want = Want.Map(itemRequest);
                return(this.Ok <Want>(want));
            }
            else
            {
                return(this.BadRequest("found nothing"));
            }
        }
Esempio n. 14
0
        public async Task <IActionResult> DeleteWant(Want model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    await _itemGenerator.DeleteWantAndPushToDbAsync(model);

                    await _userEditor.AddCurrentMoney(model.Amount);

                    await _userEditor.AddBudgetedForWants(model.Amount);

                    await _userEditor.SubtractFromAllTimeSpent(model.Amount);

                    return(RedirectToAction("Index", "Dashboard"));
                }
                catch
                {
                    return(BadRequest());
                }
            }

            return(BadRequest());
        }
Esempio n. 15
0
        public async Task <Want> CreateNeededModelForDeleteWantAsync(int Id)
        {
            Want want = await _itemFetcherService.GetSpecificWantAsync(Id);

            return(want);
        }
        public async Task <Want> GetSpecificWantAsync(int Id)
        {
            Want want = await _db.Wants.Where(a => (a.Id == Id) && (a.User == _user)).FirstOrDefaultAsync();

            return(want);
        }