public async Task <HttpStatusCode> SaveItem(BucketListItem item)
{
StringContent content = new StringContent(JsonConvert.SerializeObject(item), Encoding.UTF8, "application/json");
var response = await Client.Instance.GetClient.PostAsync("api/profile/SaveItem", content);
return(response.StatusCode);
}
private void DeletetBucketListItem_HappyPathTest_SetUps
(
string encodedUser,
string encodedToken,
string decodedUser,
string decodedToken,
User userToReturn,
BucketListItem bucketListItemToReturn,
bool returnValidToken
)
{
this.mockString.Setup(x => x.DecodeBase64String
(It.Is <string>(s => s == encodedUser)))
.Returns(decodedUser);
this.mockString.Setup(x => x.DecodeBase64String
(It.Is <string>(s => s == encodedToken)))
.Returns(decodedToken);
this.mockBucketListData.Setup(x => x.GetUser
(It.Is <string>(s => s == decodedUser)))
.Returns(userToReturn);
this.mockPassword.Setup(x => x.IsValidToken
(It.Is <User>(s => s.Email == userToReturn.Email),
It.Is <string>(s => s == decodedToken)))
.Returns(returnValidToken);
}
protected IDictionary <string, string> GetDashboardList(string pSql)
{
IDictionary <string, string> listItems = new Dictionary <string, string>();
BucketListItem bli = null;
SqlConnection conn = null;
SqlCommand cmd = null;
SqlDataReader rdr = null;
try
{
conn = new SqlConnection(connectionString);
cmd = conn.CreateCommand();
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = pSql;
cmd.Connection.Open();
rdr = cmd.ExecuteReader();
while (rdr.Read())
{
listItems.Add(GetSafeString(rdr[0]), GetSafeString(rdr[1]));
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
CloseDbObjects(conn, cmd, null);
}
return(listItems);
}
public async Task <ActionResult <BucketListItem> > AddBucketListItems(BucketListItem item)
{
_context.BucketList.Add(item);
await _context.SaveChangesAsync();
// return CreatedAtAction(nameof(GetTodoItem), new { id = item.Id }, item);
return(item);
}
public string SaveItem([FromBody] BucketListItem changedItem)
{
var item = _context.Items.Single(x => x.ID == changedItem.ID);
_context.Entry(item).CurrentValues.SetValues(changedItem);
_context.Entry(item).State = System.Data.Entity.EntityState.Modified;
_context.SaveChanges();
return("Item " + item.ID + " has been saved!");
}
public BucketListItemViewModel(BucketListItem item)
{
Item = item;
SetStatusCommand = new Command(SetStatus);
DeleteCommand = new Command(Delete);
EditCommand = new Command(x => Application.Current.MainPage.Navigation.PushAsync(new EditPage(item)));
InitStatusText();
LoadUser();
}
private void listItems_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
BucketListItem selectedItem = listItems.SelectedItem as BucketListItem;
if (selectedItem == null)
{
return;
}
Application.Current.MainPage.Navigation.PushAsync(new PublicBucketListItemPage(selectedItem));
listItems.SelectedItem = null;
}
public async Task <BucketListItem> CreateListItem(BucketListItem item)
{
string json = JsonConvert.SerializeObject(item);
StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await Client.Instance.GetClient.PostAsync("api/profile/CreateListItem",
content);
var result = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <BucketListItem>(result));
}
private async void Create()
{
BucketListItem item = new BucketListItem()
{
Created = DateTime.Now,
Item = Body,
Status = StatusConstants.IN_PROGRESS,
TargetDate = TargetDate.Date,
UserId = App.User.ID
};
//await ProfileManager.Instance.CreateListItem(Body, App.User.ID);
await ProfileManager.Instance.CreateListItem(item);
await Application.Current.MainPage.Navigation.PopAsync();
}
public async Task <ActionResult <BucketListItem> > UpdateBucketListItems(BucketListItem bucketListItem)
{
var bucketListItemInDB = await _context.BucketList.FindAsync(bucketListItem.Id);
if (bucketListItemInDB == null)
{
return(null);
}
bucketListItemInDB.NameOfBucketItem = bucketListItem.NameOfBucketItem;
bucketListItemInDB.IsComplete = bucketListItem.IsComplete;
bucketListItemInDB.PhotosLink = bucketListItem.PhotosLink;
await _context.SaveChangesAsync();
return(bucketListItemInDB);
}
public void addBucketListItemToDB(BucketListItem bli)
{
//de connectie met de databank maken
MySqlConnection conn = new MySqlConnection(_connectionString);
//Het SQL-commando definiëren
string opdracht = "INSERT INTO bucketlistdb.bucketlistitem(naam, omschrijving) VALUES(@naam, @omsch)";
MySqlCommand cmd = new MySqlCommand(opdracht, conn);
//voeg de waarden toe, je haalt ze uit het object eval
cmd.Parameters.AddWithValue("naam", bli.naam);
cmd.Parameters.AddWithValue("omsch", bli.omschrijving);
conn.Open();
cmd.ExecuteNonQuery();
conn.Close();
}
public bool UpsertBucketListItem
(
BucketListItem bucketListItem,
string encodedUser,
string encodedToken
)
{
// TODO - handle demo user at client so they cannot upsert values
bool goodUpsert = false;
if (this.IsValidToken(encodedUser, encodedToken))
{
this.bucketListData.UpsertBucketListItem(bucketListItem, this.stringHelper.DecodeBase64String(encodedUser));
goodUpsert = true;
}
return(goodUpsert);
}
private void UpsertBucketListItem_HappyPathTest_Asserts
(
string encodedUser,
string encodedToken,
string decodedUserNameToReturn,
string decodedTokenToReturn,
User userToReturn,
BucketListItem bucketListItem,
bool expectingValidTokenResponse
)
{
this.mockString.Verify(x => x.DecodeBase64String
(It.Is <string>(s => s == encodedUser))
, Times.AtLeastOnce);
this.mockString.Verify(x => x.DecodeBase64String
(It.Is <string>(s => s == encodedToken))
, Times.Once);
this.mockBucketListData.Verify(x => x.GetUser
(It.Is <string>(s => s == decodedUserNameToReturn))
, Times.Once);
this.mockPassword.Verify(x => x.IsValidToken
(It.Is <User>(s => s.Email == userToReturn.Email),
It.Is <string>(s => s == decodedTokenToReturn))
, Times.Once);
if (expectingValidTokenResponse)
{
this.mockBucketListData.Verify(x => x.UpsertBucketListItem
(It.Is <BucketListItem>(s => s.Name == bucketListItem.Name),
It.Is <string>(s => s == decodedUserNameToReturn))
, Times.Once);
}
else
{
this.mockBucketListData.Verify(x => x.UpsertBucketListItem
(It.Is <BucketListItem>(s => s.Name == bucketListItem.Name),
It.Is <string>(s => s == decodedUserNameToReturn))
, Times.Never);
}
}
protected BucketListItem GetBucketListItemObject
(
string userName = "******",
string listItemName = "Bucket list item",
int dbIdStr = 1
)
{
var model = new BucketListItem
{
Name = listItemName,
Created = DateTime.Parse("12/15/2010"),
Category = Enums.BucketListItemTypes.Hot.ToString(),
Achieved = true,
Latitude = (decimal)123.333,
Longitude = (decimal)555.1345,
Id = dbIdStr
};
return(model);
}
public void Test_GoodGetBucketListItems()
{
var bucketListItemModel = GetBucketListItemModel("base64EncodedGoodUser",
"newBucketListItem",
null,
true);
var bucketListItem = new BucketListItem()
{
Name = "newBucketListItem",
Created = System.DateTime.Now,
Category = "Hot",
Achieved = true,
Latitude = (decimal)1.1,
Longitude = (decimal)2.1
};
var bucketListItems = new List <BucketListItem>();
bucketListItems.Add(bucketListItem);
var bucketListItemsToReturn = JsonConvert.SerializeObject(bucketListItems);
mockTgimbaHttpClient.Setup(x => x.Get(It.Is <string>(s => s.Contains("/api/tgimbaapi/getbucketlistitems")),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(bucketListItemsToReturn);
var user = Shared.misc.Utilities.EncodeClientBase64String("base64EncodedGoodUser");
var results = GetWebClient().GetBucketListItems(user,
"base64EncodedGoodSortString",
"base64EncodedGoodToken",
"base64EncodedGoodSrchTerm");
Assert.IsNotNull(results);
Assert.AreEqual("newBucketListItem", results[0].Name);
mockTgimbaHttpClient.Verify(x => x.Get(It.Is <string>(s => s.Contains("/api/tgimbaapi/getbucketlistitems")),
It.IsAny <string>(),
It.IsAny <string>())
, Times.Once);
}
public void DeleteListItem(Guid itemId, Guid userId)
{
BucketListItem item = _context.Items.Single(x => x.ID == itemId);
_context.Items.Remove(item);
var events = from x in _context.UserEvents
where x.UserId == userId
select x;
foreach (var e in events)
{
if (e is UserCreatedItemEvent)
{
if (((UserCreatedItemEvent)e).ItemId == itemId)
{
_context.UserEvents.Remove(e);
}
}
}
_context.SaveChanges();
}
public BucketListItem CreateListItem([FromBody] BucketListItem item)
{
item.ID = Guid.NewGuid();
item.Created = DateTime.Now;
item.Completed = DateTime.Now;
var user = _context.Users.SingleOrDefault(x => x.ID == item.UserId);
UserCreatedItemEvent createdEvent = new UserCreatedItemEvent()
{
ItemId = item.ID,
ID = Guid.NewGuid(),
Time = DateTime.Now,
Title = user.Username + " added to their bucket list!",
UserId = user.ID,
};
_context.Items.Add(item);
_context.UserEvents.Add(createdEvent);
_context.SaveChanges();
return(item);
}
public List <BucketListItem> getBucketListItemsFromDB()
{
//de connectie met de databank maken
MySqlConnection conn = new MySqlConnection(_connectionString);
//Het SQL-commando definiëren
MySqlCommand cmd = new MySqlCommand("select * from bucketlistdb.bucketlistitem", conn);
List <BucketListItem> bucketListItemLijst = new List <BucketListItem>();
conn.Open();
MySqlDataReader dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
BucketListItem bucketlist = new BucketListItem(
Convert.ToInt16(dataReader[0]),
dataReader[1].ToString(),
dataReader[2].ToString()
);
bucketListItemLijst.Add(bucketlist);
}
conn.Close();
return(bucketListItemLijst);
}
public async Task <ActionResult <BucketListItem> > PostBucketListItem(BucketListItem bucketListItem)
{
return(await _repo.AddBucketListItems(bucketListItem));
}
public BucketListItemPage(BucketListItem item)
{
InitializeComponent();
BindingContext = new BucketListItemViewModel(item);
}
private IList <BucketListItem> GetListItemsV2(string userName, string sortString)
{
IList <BucketListItem> listItems = new List <BucketListItem>();
BucketListItem bli = null;
SqlConnection conn = null;
SqlCommand cmd = null;
SqlDataReader rdr = null;
try
{
conn = new SqlConnection(connectionString);
cmd = conn.CreateCommand();
if (!string.IsNullOrEmpty(sortString))
{
//HACK - Update in a later version
if (sortString.Equals(" order by Category"))
{
cmd.CommandText = BucketListSqlV2.GET_BUCKET_LIST + "order by CategorySortOrder";
}
else if (sortString.Equals(" order by Category desc"))
{
cmd.CommandText = BucketListSqlV2.GET_BUCKET_LIST + "order by CategorySortOrder desc";
}
else
{
cmd.CommandText = BucketListSqlV2.GET_BUCKET_LIST + sortString;
}
}
else
{
cmd.CommandText = BucketListSqlV2.GET_BUCKET_LIST;
}
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.Add(new SqlParameter("@userName", userName));
cmd.Connection.Open();
rdr = cmd.ExecuteReader();
while (rdr.Read())
{
bli = new BucketListItem();
bli.Name = GetSafeString(rdr[0]);
bli.Created = GetSafeDateTime(rdr[1]);
bli.Category = GetSafeString(rdr[2]);
bli.Achieved = GetSafeBool(rdr[3]);
bli.Id = GetSafeInt(rdr[4]);
bli.Latitude = GetSafeDecimal(rdr[5]);
bli.Longitude = GetSafeDecimal(rdr[6]);
listItems.Add(bli);
}
}
catch (Exception ex)
{
LogMsg(ex.Message);
}
finally
{
CloseDbObjects(conn, cmd, null);
}
return(listItems);
}
public EditPageViewModel(BucketListItem item)
{
Item = item;
SaveCommand = new Command(Save);
}
public EditPage(BucketListItem item)
{
this.item = item;
InitializeComponent();
BindingContext = new EditPageViewModel(item);
}
public async Task <ActionResult <BucketListItem> > UpdateBucketListItem(BucketListItem todoItemDTO)
{
return(await _repo.UpdateBucketListItems(todoItemDTO));
}
