/// <summary>
/// Posts a User
/// </summary>
/// <param name="user">Required parameter: The metadata to be saved. Metadata format has its restrictions.</param>
/// <return>Returns the Models.MessageResponse response from the API call</return>
public Models.MessageResponse PostUser(Models.Metadata user)
{
Task <Models.MessageResponse> t = PostUserAsync(user);
APIHelper.RunTaskSynchronously(t);
return(t.Result);
}
/// <summary>
/// Converts a pointer into managed metadata object.
/// </summary>
/// <param name="intPtr">Native pointer.</param>
/// <returns>Metadata managed object.</returns>
internal static Models.Metadata PtrToMetadata(this IntPtr intPtr)
{
var managedMetaObject = new Models.Metadata();
var metaData = (Metadata)Marshal.PtrToStructure(intPtr, typeof(Metadata));
managedMetaObject.Items = new Models.MetadataItem[metaData.num_items];
managedMetaObject.Probability = metaData.probability;
//we need to manually read each item from the native ptr using its size
var sizeOfMetaItem = Marshal.SizeOf(typeof(MetadataItem));
for (int i = 0; i < metaData.num_items; i++)
{
var tempItem = Marshal.PtrToStructure <MetadataItem>(metaData.items);
managedMetaObject.Items[i] = new Models.MetadataItem
{
Timestep = tempItem.timestep,
StartTime = tempItem.start_time,
Character = tempItem.character.PtrToString(releasePtr: false)
};
//we keep the offset on each read
metaData.items += sizeOfMetaItem;
}
NativeImp.DS_FreeMetadata(intPtr);
return(managedMetaObject);
}
/// <summary>
/// Posts An Item
/// </summary>
/// <param name="item">Required parameter: The metadata to be saved. Metadata format has its restrictions.</param>
/// <return>Returns the Models.MessageResponse response from the API call</return>
public Models.MessageResponse PostItem(Models.Metadata item)
{
Task <Models.MessageResponse> t = PostItemAsync(item);
APIHelper.RunTaskSynchronously(t);
return(t.Result);
}
/// <summary>
/// Posts a User
/// </summary>
/// <param name="user">Required parameter: The metadata to be saved. Metadata format has its restrictions.</param>
/// <return>Returns the Models.MessageResponse response from the API call</return>
public async Task <Models.MessageResponse> PostUserAsync(Models.Metadata user)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/users");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "SUGGESTGRID" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(user);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if (_response.StatusCode == 400)
{
throw new DetailedErrorResponseException(@"Metadata is invalid.", _context);
}
if ((_response.StatusCode < 200) || (_response.StatusCode > 208)) //[200,208] = HTTP OK
{
throw new ErrorResponseException(@"Unexpected internal error.", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.MessageResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
private void ClientRename()
{
if (!Directory.Exists(e.LocalPath) && !File.Exists(e.LocalPath))
{
return;
}
Models.SQLDataType sdt = Util.SqliteHelper.Select(e.OldLocalPath);
sdt.Path = e.LocalPath;
Util.SqliteHelper.Delete(e.OldLocalPath);
Util.SqliteHelper.Insert(sdt);
Models.Metadata renameResult = NetworkManager.Rename(e.CloudPath, e.OldCloudPath);
}
public FieldNotes()
{
location = new Models.FieldLocation(); //Init as a new class
station = new Models.Station();
metadata = new Models.Metadata();
earthmat = new Models.EarthMaterial();
sample = new Models.Sample();
favorite = new Models.Favorite();
document = new Models.Document();
structure = new Models.Structure();
paleoflow = new Models.Paleoflow();
fossil = new Models.Fossil();
mineral = new Models.Mineral();
mineralAlteration = new Models.MineralAlteration();
}
private void ServerChange()
{
Models.Metadata metadata = NetworkManager.GetMetadata(e.CloudPath);
if (metadata.Tag.Equals("File"))
{
while (!NetworkManager.Download(e.CloudPath))
{
Thread.Sleep(5000);
}
metadata = NetworkManager.GetMetadata(e.CloudPath);
File.SetLastWriteTimeUtc(e.LocalPath, metadata.ModifiedTime);
Models.SQLDataType sdt = new Models.SQLDataType(e.LocalPath,
metadata.ModifiedTime,
metadata.Rev,
metadata.Modifier.Email,
metadata.isShared ? "true" : "false");
Util.SqliteHelper.Update(sdt);
}
}
/// <summary>
/// Converts a pointer into managed Metadata object.
/// </summary>
/// <param name="intPtr">Native pointer.</param>
/// <returns>Metadata managed object.</returns>
internal static Models.Metadata PtrToMetadata(this IntPtr intPtr)
{
var managedMetadata = new Models.Metadata();
var metadata = Marshal.PtrToStructure <Metadata>(intPtr);
managedMetadata.Transcripts = new Models.CandidateTranscript[metadata.num_transcripts];
//we need to manually read each item from the native ptr using its size
var sizeOfCandidateTranscript = Marshal.SizeOf(typeof(CandidateTranscript));
for (int i = 0; i < metadata.num_transcripts; i++)
{
managedMetadata.Transcripts[i] = metadata.transcripts.PtrToCandidateTranscript();
metadata.transcripts += sizeOfCandidateTranscript;
}
NativeImp.STT_FreeMetadata(intPtr);
return(managedMetadata);
}
private void ServerRename()
{
Models.Metadata metadata = NetworkManager.GetMetadata(e.CloudPath);
if (metadata.Tag.Equals("File"))
{
bool retry = true;
while (retry)
{
try
{
new FileInfo(e.OldLocalPath).MoveTo(e.LocalPath);
retry = false;
}
catch (IOException)
{
Thread.Sleep(5000);
}
}
}
else
{
bool retry = true;
while (retry)
{
try
{
new DirectoryInfo(e.OldLocalPath).MoveTo(e.LocalPath);
retry = false;
}
catch (IOException)
{
Thread.Sleep(5000);
}
}
}
Models.SQLDataType sdt = Util.SqliteHelper.Select(e.OldLocalPath);
sdt.Path = e.LocalPath;
Util.SqliteHelper.Delete(e.OldLocalPath);
Util.SqliteHelper.Insert(sdt);
}