/// <summary>
/// Repost the specified meme by the specified user
/// </summary>
/// <param name="meme"></param>
/// <param name="user"></param>
/// <returns></returns>
public IMeme RepostMeme(IMeme meme, IUser user)
{
IRepost repost = new Repost
{
DateCreated = DateTime.Now.ToUniversalTime(),
MemeId = meme.RepostOfId ?? meme.Id, // If the meme being reposted is also a repost then use the original meme as the "repost of" id
UserId = user.Id,
UserName = user.UserName
};
// Save the repost
repository.Save(repost);
// Increment the repost count of the meme and its creator
meme = Reposted(meme);
// Add repost to time line
repository.Save(new TimeLine(user.Id, TimeLineEntry.Repost, repost.MemeId, meme.Id, null, null));
// Update the number of reposts performed by this user
user.Reposts++;
// Save commentator
repository.Save(user);
return(meme);
}
public static RepostViewModel FromRepost(Repost repost)
{
return(new RepostViewModel
{
Id = repost.Id,
User = UserSummaryViewModel.FromUser(repost.User)
});
}
async Task <Repost> HeritagesPutRequest(string route)
{
HttpContent content = new StringContent("");
HttpResponseMessage response = await HttpClient.PutAsync($"{ApiBaseUrl}{route}", content);
var repostage = await response.Content.ReadAsStringAsync();
Repost repost = JsonConvert.DeserializeObject <Repost>(repostage);
repost.Success = response.IsSuccessStatusCode;
return(repost);
}
async Task <Repost> UserPutRequest(User user, string route)
{
var data = JsonConvert.SerializeObject(user);
var content = new StringContent(data, Encoding.UTF8, "application/json");
HttpResponseMessage response = await HttpClient.PutAsync($"{ApiBaseUrl}{route}", content);
var repostage = await response.Content.ReadAsStringAsync();
Repost repost = JsonConvert.DeserializeObject <Repost>(repostage);
repost.Success = response.IsSuccessStatusCode;
return(repost);
}
async Task <Repost> MaintenancePostRequest(Maintenance maintenance)
{
var data = JsonConvert.SerializeObject(maintenance);
var content = new StringContent(data, Encoding.UTF8, "application/json");
HttpResponseMessage response = await HttpClient.PostAsync($"{ApiBaseUrl}maintenance/{maintenance.CompanyId}", content);
var repostage = await response.Content.ReadAsStringAsync();
Repost repost = JsonConvert.DeserializeObject <Repost>(repostage);
repost.Success = response.IsSuccessStatusCode;
return(repost);
}
async Task <Repost> EnvironmentPostRequest(Environment environment)
{
var data = JsonConvert.SerializeObject(environment.Name);
var content = new StringContent(data, Encoding.UTF8, "application/json");
HttpResponseMessage response = await HttpClient.PostAsync($"{ApiBaseUrl}environments", content);
var repostage = await response.Content.ReadAsStringAsync();
Repost repost = JsonConvert.DeserializeObject <Repost>(repostage);
repost.Success = response.IsSuccessStatusCode;
return(repost);
}
async Task <Repost> HeritagePutRequest(Heritage heritage)
{
heritage.SerializeCode = false;
var data = JsonConvert.SerializeObject(heritage);
var content = new StringContent(data, Encoding.UTF8, "application/json");
HttpResponseMessage response = await HttpClient.PutAsync($"{ApiBaseUrl}heritages/{heritage.Id}", content);
var repostage = await response.Content.ReadAsStringAsync();
Repost repost = JsonConvert.DeserializeObject <Repost>(repostage);
repost.Success = response.IsSuccessStatusCode;
return(repost);
}
public void Repost(Post post, User reposter)
{
using (var unitOfWork = UnitOfWork.GetUnitOfWork())
{
var userRepository = unitOfWork.GetRepository <User>();
var postRepository = unitOfWork.GetRepository <Post>();
var repostRepository = unitOfWork.GetRepository <Repost>();
userRepository.Attach(reposter);
postRepository.Attach(post);
var repost = new Repost {
PostedTime = DateTime.Now, Author = reposter, OriginalPost = post
};
repostRepository.Insert(repost);
unitOfWork.CommitChanges();
}
}
//async Task<Repost> FilePostRequest(MediaFile file)
//{
// var fileBytes = System.IO.File.ReadAllBytes(file);
// MultipartFormDataContent content = new MultipartFormDataContent();
// ByteArrayContent byteArray = new ByteArrayContent();
// content.Add();
// HttpResponseMessage response = await HttpClient.PostAsync($"{ApiBaseUrl}maintenance/{maintenance.CompanyId}", content);
// var repostage = await response.Content.ReadAsStringAsync();
// Repost repost = JsonConvert.DeserializeObject<Repost>(repostage);
// repost.Success = response.IsSuccessStatusCode;
// return repost;
//}
public async Task <Repost> PostAsync(Maintenance maintenance)
{
Repost repost = new Repost();
try
{
var func = new Func <Task <Repost> >(() => MaintenancePostRequest(maintenance));
repost = await _networkService.Retry(func, 3, OnRetry);
}
catch (Exception ex)
{
throw ex;
}
return(repost);
}
public async Task <bool> VerificationAsync(int?EnvironmentId)
{
Repost repost = new Repost();
try
{
var func = new Func <Task <Repost> >(() => HeritagesPutRequest($"conferences/{EnvironmentId}"));
repost = await _networkService.Retry(func, 3, OnRetry);
}
catch (Exception ex)
{
throw ex;
}
return(repost.Success);
}
public async Task <bool> PutAsync(Heritage heritage)
{
Repost repost = new Repost();
try
{
var func = new Func <Task <Repost> >(() => HeritagePutRequest(heritage));
repost = await _networkService.Retry(func, 3, OnRetry);
}
catch (Exception ex)
{
throw ex;
}
return(repost.Success);
}
public async Task <Repost> PostAsync(Environment environment)
{
Repost repost = new Repost();
try
{
var func = new Func <Task <Repost> >(() => EnvironmentPostRequest(environment));
repost = await _networkService.Retry(func, 3, OnRetry);
}
catch (Exception ex)
{
throw ex;
}
return(repost);
}
public async Task <bool> DeleteAsync(User user)
{
Repost repost = new Repost();
try
{
var func = new Func <Task <Repost> >(() => UserPutRequest(user, $"users/{user.Id}"));
repost = await _networkService.Retry(func, 3, OnRetry);
}
catch (Exception ex)
{
throw ex;
}
return(repost.Success);
}
public async Task <Repost> AddUserAsync(User user)
{
Repost repost = new Repost();
try
{
var func = new Func <Task <Repost> >(() => UserPutRequest(user, $"company/users/{user.Email}"));
repost = await _networkService.Retry(func, 3, OnRetry);
}
catch (Exception ex)
{
throw ex;
}
return(repost);
}
private async void ExecuteAddCommand()
{
try
{
Body = false;
Load = true;
if (Maintenance.Problem != null)
{
Repost repost = await HeritageAPIService.PostAsync(Maintenance);
if (repost.Success)
{
Xamarin.Forms.DependencyService.Get <IMessage>().LongAlert("Manutenção adicionada com sucesso");
await NavigationService.GoBackAsync();
}
else
{
var param = new DialogParameters
{
{ "Message", repost.ErrorMessage },
{ "Title", "Erro" },
{ "Icon", IconTheme.IconName("bug") }
};
DialogService.ShowDialog("DialogPage", param, CloseDialogCallback);
}
}
else
{
Xamarin.Forms.DependencyService.Get <IMessage>().LongAlert("Preencha todos os campos");
}
}
catch (Exception ex)
{
Xamarin.Forms.DependencyService.Get <IMessage>().LongAlert("Erro ao adicionar manutenção");
Console.WriteLine($"Erro ao adicionar patrimônio: {ex.Message}, Página: AdicionarPatrimonio");
Load = false;
}
finally
{
IsBusy = false;
Body = true;
Load = false;
}
}
private void Reshare_Tapped(object sender, TappedRoutedEventArgs e)
{
e.Handled = true;
Repost?.Invoke(this, new WeiboActionEventArgs((e.OriginalSource as FrameworkElement).DataContext as BaseModel));
}
