public IRestResponse <PostChallenge> ApiPost(string challengeId, string id, List <InputValue> values)
{
var baseurl = "http://htf2018.azurewebsites.net/";
var client = new RestClient();
client.BaseUrl = new System.Uri(baseurl);
var request = new RestRequest(String.Format("challenges/{0}", id), Method.POST);
request.AddHeader("Content-type", "application/json");
request.AddHeader("htf-identification", "ZGJkOWZjOGUtODE4NS00YjEzLWI0OWQtMjUxZmU3MTIwODVk");
PostObject obj = new PostObject();
obj.challengeId = challengeId;
obj.values = values;
var json = request.JsonSerializer.Serialize(obj);
request.AddParameter("application/json; charset=utf-8", json, ParameterType.RequestBody);
PostChallenge challenge = new PostChallenge();
IRestResponse <PostChallenge> response = client.Execute <PostChallenge>(request);
return(response);
}
public ActionResult Create(PostObject ob)
{
string result = "";
try
{
// TODO: Add insert logic here
ob.AccountID = new Models.User().GetAcount().AccountID;
ob.PostId = Guid.Parse(Request.Form["postId"]);
ob.CarCode = (long)new Random().NextDouble();
ob.PostDay = DateTime.Now;
if (new PostBCL().Insert(ob))
{
return(RedirectToAction("Index"));
}
else
{
result = "Thêm Bài đăng thất bại";
}
}
catch (Exception ex)
{
result = ex.Message;
}
ModelState.AddModelError("", result);
return(View());
}
public void Initialize([NotNull] PostObject post)
{
headerImage.sprite = post.character.profilePicture;
headerName.text = post.character.GetNameString();
headerTimestamp.text = post.GetTimestampString();
if (post.image != null)
{
image.sprite = post.image;
}
else
{
Destroy(image.gameObject);
}
text.text = Localization.Localization.Get(post.text);
_commentCollection = GetComponentInChildren <CommentCollection>();
if (post.comments.Length == 0)
{
Destroy(_commentCollection.gameObject);
}
else
{
_commentCollection.Initialize(post.comments);
}
}
public async Task <ResponseWrapper> Post([FromBody] PostObject postData)
{
ResponseWrapper response = new ResponseWrapper();
try
{
if (postData.Method.Equals("POST"))
{
response = await _makeAPICallService.MakePostAPICall(postData);
return(response);
}
else
{
response = await _makeAPICallService.MakeGetAPICall(postData);
return(response);
}
}
catch
{
response.Code = -1;
response.Data = "Error, Invalid or missing parameter(s).";
return(response);
}
}
public async void PostObject(IPostServiceDelegate <object> handler, PostObject <object> postObject)
{
ResultObj <object> result = new ResultObj <object>();
try
{
var uri = new Uri(String.Format(Config.BASE_SERVICE_URL + postObject.PostAction.Url));
var json = JsonConvert.SerializeObject(postObject);
var content = new StringContent(json, Encoding.UTF8, "application/json");
responseMessage = await httpClient.PostAsync(uri, content);
if (responseMessage.IsSuccessStatusCode)
{
JsonSerializerSettings serSettings = new JsonSerializerSettings();
serSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var data = responseMessage.Content.ReadAsStringAsync().Result;
result = JsonConvert.DeserializeObject <ResultObj <object> >(data.ToString());
handler.HandlePostResults(result);
}
else
{
result.Error = responseMessage.StatusCode.ToString();
handler.HandlePostResults(result);
}
}
catch (Exception ex)
{
result.isSuccessful = false;
result.Error = ex.Message;
handler.HandlePostResults(result);
}
}
public void PostObject(IPostServiceDelegate <object> handler, PostObject <object> postObject)
{
ResultObj <object> result = new ResultObj <object>();
result.Error = string.Empty;
result.isSuccessful = true;
try
{
var json = JsonConvert.SerializeObject(postObject.Data);
switch (postObject.PostAction.Code)
{
case ActionCode.login:
//SaveCoverpage(JsonConvert.DeserializeObject<CoverPageModel>(json));
handler.HandlePostResults(result);
break;
}
}
catch (Exception ex)
{
result.Error = ex.Message;
result.isSuccessful = false;
handler.HandlePostResults(result);
}
}
public void EntryBookInfo()
{
Book book = new Book();
Console.WriteLine("Entry Book Information Center");
Console.WriteLine("===============================");
Console.Write("Please enter Book Title: ");
book.Title = Console.ReadLine();
Console.Write("Please enter Book Author: ");
book.Author = Console.ReadLine();
Console.Write("Please enter Book Edition: ");
book.Edition = Console.ReadLine();
Console.Write("Please enter Barcode of the book: ");
book.BarCode = Console.ReadLine();
Console.Write("Please enter Copy Count of the book: ");
book.CopyCount = int.Parse(Console.ReadLine());
Console.WriteLine("===============================");
PostObject BookEntry = new PostObject();
BookEntry.Insert(book, "Books");
}
private void InstantiatePost([NotNull] PostObject post)
{
var instance = Instantiate(postPrefab, transform);
var script = instance.GetComponent <Post>();
script.Initialize(post);
}
public async Task Execute(IJobExecutionContext context)
{
using (var client = new HttpClient {
Timeout = TimeSpan.FromSeconds(30)
})
{
PostObject postObject = new PostObject
{
NotificationContent = new NotificationContent
{
Name = "Campaign Name",
Title = "Expired Warning",
Body = "You have items that almost expired"
}
};
var myContent = JsonConvert.SerializeObject(postObject);
client.DefaultRequestHeaders.Add("X-API-Token", "b547b248fe7321c091f0027116a0aa84569eff85");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var builder = new UriBuilder(new Uri("https://appcenter.ms/api/v0.1/apps/KacangIjo/ShopDiaryApp/push/notifications"));
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, builder.Uri);
request.Content = new StringContent(myContent, Encoding.UTF8, "application/json");//CONTENT-TYPE header
HttpResponseMessage response = await client.SendAsync(request);
};
}
// test post call
public static async Task <string> PostRawPostmanEcho(bool forceRefresh = false)
{
IWebApiClient <IPostmanEcho> webApiClient = WebApiClientFactory.Get <IPostmanEcho>("https://postman-echo.com/", false);
PostObject postObject = new PostObject();
postObject.testName = "hello world";
postObject.testDate = DateTime.Now.ToString();
var postObjectResult = await webApiClient.Call(
(service) => service.PostObject(postObject),
Priority.UserInitiated,
2,
(ex) => true,
60);
var postResult = await webApiClient.Call(
(service) => service.Post("test"),
Priority.UserInitiated,
2,
(ex) => true,
60);
Console.WriteLine("\t Post string: ");
ConvertJson(postResult);
Console.WriteLine("\t Post object: ");
ConvertJson(postObjectResult);
return(postResult);
}
public async Task <IActionResult> Post([FromBody] PostObject postObject)
{
var id = await _postService.CreatePost(postObject);
postObject.Id = id;
return(CreatedAtRoute("GetPost", new { id }, postObject));
}
public async Task <ResponseWrapper> MakeGetAPICall(PostObject postData)
{
ResponseWrapper responseWrapper = new ResponseWrapper();
responseWrapper.Code = -1;
try
{
SetHeader(postData.HeadersList);
var builder = new UriBuilder(postData.RequestUrl);
builder.Port = -1;
var query = HttpUtility.ParseQueryString(builder.Query);
if (postData.JsonData != null)
{
var headers = JsonConvert.DeserializeObject <Dictionary <string, string> >(postData.JsonData);
foreach (KeyValuePair <string, string> entry in headers)
{
query[entry.Key] = entry.Value;
}
builder.Query = query.ToString();
}
string url = builder.ToString();
var response = await _client.GetAsync(url);
responseWrapper.Code = 1;
responseWrapper.Data = response.Content.ReadAsStringAsync().Result;
}
catch (Exception ex)
{
responseWrapper.Data = ex.Message;
}
return(responseWrapper);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
PostObject.DisposeObject();
fSource.DisposeObject();
}
}
public void AddCustomerInformation(INFORMATION information)
{
var postObject = new PostObject <object>();
PostAction action = Config.PostActions.Where(o => o.Code == ActionCode.AddInformation).SingleOrDefault();
postObject.PostAction = action;
postObject.Data = information;
this._service.PostObject(this, postObject);
}
public IHttpActionResult SaveInformation([FromBody] PostObject <object> postObject)
{
JsonSerializerSettings serSettings = new JsonSerializerSettings();
serSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
INFORMATION info = JsonConvert.DeserializeObject <INFORMATION>(postObject.Data.ToString(), serSettings);
var result = this._informationProvider.AddInformation(info);
return(Ok(result));
}
public async Task <IActionResult> Put([FromRoute] int id, [FromBody] PostObject postObject)
{
var updatedId = await _postService.UpdatePost(postObject, id);
if (updatedId == -1)
{
return(NotFound());
}
return(Ok(updatedId));
}
public async Task <long> CreatePost(PostObject postObj)
{
var post = new Post()
{
Author = postObj.Author,
Title = postObj.Title,
Text = postObj.Text,
CreateDate = DateTime.Now
};
await _database.AddAsync(post);
await _database.SaveChangesAsync();
return(post.Id);
}
public void ReturnBook()
{
ReturnBook bookReturn = new ReturnBook();
Console.WriteLine("Return a book ");
Console.WriteLine("===============================");
Console.Write("Please Enter Student Id : ");
bookReturn.StudentId = int.Parse(Console.ReadLine());
Console.Write("Please Enter Book Barcode : ");
bookReturn.BookBarCode = Console.ReadLine();
PostObject postObject = new PostObject();
postObject.Insert(bookReturn, "ManagingLibrary/ReturnBook");
}
public PostModel ToPostModelFrom(PostObject postObject)
{
var post = new PostModel();
post.DateCreated = postObject.DateCreated;
post.Comments = ToCommentModelFrom(postObject.Comments.ToList());
post.Desription = postObject.Description;
post.Image = postObject.Image;
post.Likes = ToLikeModelFrom(postObject.Likes.ToList());
post.User = ToUserModelFrom(postObject.Author);
post.IsLiked = CurrentUser.User?.LikedPosts?.FirstOrDefault(x => x?.Post?.Id == post.Id) != null;
post.IsSaved = CurrentUser.User?.SavedPosts?.FirstOrDefault(x => x?.Post?.Id == post.Id) != null;
return(post);
}
public void IssueBook()
{
IssueBook bookIssue = new IssueBook();
Console.WriteLine("Issue a book to student");
Console.WriteLine("===============================");
Console.Write("Please Enter Student Id : ");
bookIssue.StudentId = int.Parse(Console.ReadLine());
Console.Write("Please Enter Book Barcode : ");
bookIssue.BookBarCode = Console.ReadLine();
Console.WriteLine("===============================");
PostObject IssueBook = new PostObject();
IssueBook.Insert(bookIssue, "ManagingLibrary/IssueBook");
}
public IEnumerator postCell(string cellInfos, string cellName)
{
string url = "https://pnk98uo8jf.execute-api.eu-west-2.amazonaws.com/prod/cell";
PostObject postObject = new PostObject(cellInfos, cellName);
string jsonStringTrial = JsonUtility.ToJson(postObject);
UnityWebRequest www = UnityWebRequest.Put(url, jsonStringTrial);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log("error");
}
}
public void Create_Calls_RequestHelperAndClient_Returns_ResultFromResponse()
{
var postObject = new PostObject();
var expectedResult = new GetObject();
var response = new RestResponse <GetObject>
{
Data = expectedResult
};
_requestHelper.Setup(c => c.BuildRequest(_urlAppend, Method.POST, postObject, null)).Returns(_restRequest.Object);
_restClient.Setup(c => c.ExecuteAsPost <GetObject>(_restRequest.Object, "POST")).Returns(response);
_initializer.Setup(c => c.Get()).Returns(_restClient.Object);
var result = _connector.Create(postObject);
_requestHelper.Verify(c => c.CheckResult(response));
result.Should().BeEquivalentTo(expectedResult);
}
public void EntryStudentInfo()
{
Student student = new Student();
Console.WriteLine("Entry Student Information center");
Console.WriteLine("===============================");
Console.Write("Please enter student Id: ");
student.Id = int.Parse(Console.ReadLine());
Console.Write("Please enter student Name: ");
student.Name = Console.ReadLine();
student.FineAmount = 0;
Console.WriteLine("===============================");
PostObject entryStudent = new PostObject();
entryStudent.Insert(student, "Students");
}
public void Update_Calls_RequestHelperAndClient_Returns_ResultFromResponse()
{
long inputId = 1234;
var postObject = new PostObject();
var expectedResult = new GetObject();
var response = new RestResponse <GetObject>
{
Data = expectedResult
};
_requestHelper.Setup(c => c.BuildRequest($"{ _urlAppend}/{inputId}", Method.PATCH, postObject, null)).Returns(_restRequest.Object);
_restClient.Setup(c => c.ExecuteAsPost <GetObject>(_restRequest.Object, "PATCH")).Returns(response);
_initializer.Setup(c => c.Get()).Returns(_restClient.Object);
var result = _connector.Update(inputId, postObject);
_requestHelper.Verify(c => c.CheckResult(response));
result.Should().BeEquivalentTo(expectedResult);
}
public async Task <long> UpdatePost(PostObject post, long id)
{
var oldPost = await _database.Posts.FirstOrDefaultAsync(x => x.Id == id);
if (oldPost == null)
{
id = -1;
}
else
{
oldPost.Title = post.Title;
oldPost.Author = post.Author;
oldPost.Text = post.Text;
oldPost.CreateDate = DateTime.Now;
_database.Posts.Update(oldPost);
await _database.SaveChangesAsync();
}
return(id);
}
public async Task <PostObject> Get(int id)
{
var postObject = new PostObject();
var post = await _postService.GetPost(id);
if (post != null)
{
postObject.Id = post.Id;
postObject.Author = post.Author;
postObject.CommentCount = post.Comments.Count;
postObject.CreateDate = post.CreateDate;
postObject.Text = post.Text;
postObject.Title = post.Title;
}
else
{
postObject.Id = -1;
}
return(postObject);
}
public void When_Information_Added_Should_Return_True()
{
IUnitOfWork unitOfWork = new UnitOfWork();
IInformationProvider provider = new InformationProvider(unitOfWork);
INFORMATION info = new INFORMATION();
info.ID_NO = "9812135489081";
InformationController controller = new InformationController(provider);
PostObject <object> post = new PostObject <object>();
post.Data = JsonConvert.SerializeObject(info);
var res = controller.SaveInformation(post);
Assert.IsNotNull(res);
// var result = provider.AddInformation(info);
// Assert.IsNotNull(result.Success);
}
public async Task <IEnumerable <PostObject> > GetAll(int limit = 15)
{
var posts = await _postService.GetAllPosts(limit);
var postObjectList = new List <PostObject>();
foreach (var post in posts)
{
var postObject = new PostObject()
{
Id = post.Id,
Author = post.Author,
CreateDate = post.CreateDate,
Text = post.Text,
Title = post.Title,
CommentCount = post.Comments.Count
};
postObjectList.Add(postObject);
}
return(postObjectList);
}
public ActionResult Edit(PostObject ob, FormCollection collection)
{
string result = "";
try
{
// TODO: Add update logic here
if (new PostBCL().Update(ob))
{
return(RedirectToAction("Index"));
}
else
{
result = "Sửa Bài đăng thất bại";
}
}
catch (Exception ex)
{
result = ex.Message;
}
ModelState.AddModelError("", result);
return(View());
}
public DatabaseResponseWithData <IEnumerable <UserModel> > GetAllUsers()
{
IEnumerable <UserObject> users = null;
var user = new UserObject {
FirstName = "b", LastName = "v", Email = "*****@*****.**", Password = "******"
};
var post = new PostObject();
var saved = new SavedPostObject {
Post = post
};
try {
users = _realmRepository.GetAllUsers();
//_realmRepository.AddUser ( user );
} catch (RealmException realmEx) {
return(new DatabaseResponseWithData <IEnumerable <UserModel> > (false, realmEx.Message));
} catch (Exception ex) {
return(new DatabaseResponseWithData <IEnumerable <UserModel> > (false, ex.Message));
}
var mapped = _realmDatabaseMapper.ToUserModelFrom(users.ToList());
return(new DatabaseResponseWithData <IEnumerable <UserModel> > (true, null, mapped));
}
