private bool CheckNamedUserPermission(Guid userId, RepositoryModel repository, RepositoryAccessLevel requiredLevel)
{
if (userId == Guid.Empty)
{
throw new ArgumentException("Do not pass anonymous user id", "userId");
}
bool userIsAnAdministrator = IsAnAdminstrator(userId, repository);
var userIsATeamMember =
TeamRepository.GetTeams(userId)
.Any(x => repository.Teams.Select(y => y.Name).Contains(x.Name, StringComparer.OrdinalIgnoreCase));
var userIsARepoUser = repository.Users.Any(x => x.Id == userId);
switch (requiredLevel)
{
case RepositoryAccessLevel.Push:
case RepositoryAccessLevel.Pull:
return(userIsARepoUser || userIsATeamMember || userIsAnAdministrator);
case RepositoryAccessLevel.Administer:
return(userIsAnAdministrator);
default:
throw new ArgumentOutOfRangeException("requiredLevel", requiredLevel, null);
}
}
public IObservable <Repository> ForkRepository(IApiClient apiClient, RepositoryModel sourceRepository, NewRepositoryFork repositoryFork, bool updateOrigin, bool addUpstream, bool trackMasterUpstream)
{
log.Verbose("ForkRepository Source:{SourceOwner}/{SourceName} To:{DestinationOwner}", sourceRepository.Owner, sourceRepository.Name, repositoryFork.Organization ?? "[Current User]");
log.Verbose("ForkRepository updateOrigin:{UpdateOrigin} addUpstream:{AddUpstream} trackMasterUpstream:{TrackMasterUpstream}", updateOrigin, addUpstream, trackMasterUpstream);
usageTracker.IncrementCounter(model => model.NumberOfReposForked).Forget();
return(Observable.Defer(() => apiClient.ForkRepository(sourceRepository.Owner, sourceRepository.Name, repositoryFork)
.ObserveOn(RxApp.MainThreadScheduler)
.Select(remoteRepo => new { RemoteRepo = remoteRepo, ActiveRepo = updateOrigin ? vsGitServices.GetActiveRepo() : null }))
.SelectMany(async repo =>
{
if (repo.ActiveRepo != null)
{
using (repo.ActiveRepo)
{
var originUri = repo.RemoteRepo != null ? new Uri(repo.RemoteRepo.CloneUrl) : null;
var upstreamUri = addUpstream ? sourceRepository.CloneUrl.ToUri() : null;
await SwitchRemotes(repo.ActiveRepo, originUri, upstreamUri, trackMasterUpstream);
}
}
return repo.RemoteRepo;
}));
}
public IObservable <Unit> SwitchRemotes(RepositoryModel destinationRepository, bool updateOrigin, bool addUpstream, bool trackMasterUpstream)
{
return(Observable.Defer(() => Observable.Return(new object())
.ObserveOn(RxApp.MainThreadScheduler)
.Select(_ => vsGitServices.GetActiveRepo()))
.SelectMany(async activeRepo =>
{
using (activeRepo)
{
Uri currentOrigin = null;
if (addUpstream)
{
var remote = await gitClient.GetHttpRemote(activeRepo, "origin");
currentOrigin = new Uri(remote.Url);
}
await SwitchRemotes(activeRepo, updateOrigin ? destinationRepository.CloneUrl.ToUri() : null,
currentOrigin, trackMasterUpstream);
}
if (updateOrigin)
{
vsGitExt.RefreshActiveRepositories();
var updatedRepository = vsGitExt.ActiveRepositories.FirstOrDefault();
log.Assert(updatedRepository?.CloneUrl == destinationRepository.CloneUrl,
"CloneUrl is {UpdatedRepository} not {DestinationRepository}", updatedRepository?.CloneUrl ?? "[NULL]", destinationRepository.CloneUrl);
}
return Unit.Default;
}));
}
static TestData PrepareTestData(
string repoName, string sourceRepoOwner, string sourceBranchName,
string targetRepoOwner, string targetBranchName,
string remote,
bool repoIsFork, bool sourceBranchIsTracking)
{
var serviceProvider = Substitutes.ServiceProvider;
var gitService = serviceProvider.GetGitService();
var gitClient = Substitute.For <IGitClient>();
var notifications = Substitute.For <INotificationService>();
var host = Substitute.For <IRepositoryHost>();
var api = Substitute.For <IApiClient>();
var ms = Substitute.For <IModelService>();
// this is the local repo instance that is available via TeamExplorerServiceHolder and friends
var activeRepo = Substitute.For <ISimpleRepositoryModel>();
activeRepo.LocalPath.Returns("");
activeRepo.Name.Returns(repoName);
activeRepo.CloneUrl.Returns(new GitHub.Primitives.UriString("http://github.com/" + sourceRepoOwner + "/" + repoName));
activeRepo.Owner.Returns(sourceRepoOwner);
Repository githubRepoParent = null;
if (repoIsFork)
{
githubRepoParent = CreateRepository(targetRepoOwner, repoName, id: 1);
}
var githubRepo = CreateRepository(sourceRepoOwner, repoName, id: 2, parent: githubRepoParent);
var sourceBranch = new BranchModel(sourceBranchName, activeRepo);
var sourceRepo = new RepositoryModel(githubRepo);
var targetRepo = targetRepoOwner == sourceRepoOwner ? sourceRepo : sourceRepo.Parent;
var targetBranch = targetBranchName != targetRepo.DefaultBranch.Name ? new BranchModel(targetBranchName, targetRepo) : targetRepo.DefaultBranch;
activeRepo.CurrentBranch.Returns(sourceBranch);
serviceProvider.GetRepositoryHosts().GitHubHost.Returns(host);
host.ApiClient.Returns(api);
host.ModelService.Returns(ms);
api.GetRepository(Args.String, Args.String).Returns(Observable.Return(githubRepo));
// sets up the libgit2sharp repo and branch objects
var l2repo = SetupLocalRepoMock(gitClient, gitService, remote, sourceBranchName, sourceBranchIsTracking);
return(new TestData
{
ServiceProvider = serviceProvider,
ActiveRepo = activeRepo,
L2Repo = l2repo,
SourceRepo = sourceRepo,
SourceBranch = sourceBranch,
TargetRepo = targetRepo,
TargetBranch = targetBranch,
GitClient = gitClient,
GitService = gitService,
NotificationService = notifications,
RepositoryHost = host,
ApiClient = api,
ModelService = ms
});
}
public ActionResult Create(RepositoryModel model)
{
if (ModelState.IsValid)
{
try
{
var repo = RepositoryService.Create(model);
if (repo != null)
{
var success = GitService.CreateRepository(model.Owner, model.Name);
if (!success)
{
RepositoryService.Delete(Token.Username, model.Name);
repo = null;
}
}
if (repo != null)
{
return(RedirectToAction("Tree", "Repository", new { owner = model.Owner, name = repo.Name }));
}
}
catch (ArgumentException ex)
{
//ModelState.AddModelError(ex.ParamName, SR.Repository_AlreadyExists);
ModelState.AddModelError(ex.ParamName, ex.Message);
}
catch (Exception ex)
{
ModelState.AddModelError("", ex);
}
}
return(CreateView(model));
}
private bool TryCreateOnPush(string repositoryName)
{
DirectoryInfo directory = GetDirectoryInfo(repositoryName);
if (directory.Exists)
{
// We can't create a new repo - there's already a directory with that name
Log.Warning("GitC: Can't create {RepositoryName} - directory already exists", repositoryName);
return(false);
}
RepositoryModel repository = new RepositoryModel();
repository.Name = repositoryName;
if (!repository.NameIsValid)
{
// We don't like this name
Log.Warning("GitC: Can't create '{RepositoryName}' - name is invalid", repositoryName);
return(false);
}
var user = MembershipService.GetUserModel(User.Id());
repository.Description = "Auto-created by push for " + user.DisplayName;
repository.AnonymousAccess = false;
repository.Administrators = new[] { user };
if (!RepositoryRepository.Create(repository))
{
// We can't add this to the repo store
Log.Warning("GitC: Can't create '{RepositoryName}' - RepoRepo.Create failed", repositoryName);
return(false);
}
Repository.Init(Path.Combine(UserConfiguration.Current.Repositories, repository.Name), true);
Log.Information("GitC: '{RepositoryName}' created", repositoryName);
return(true);
}
static async Task <CloneDialogResult> ShowCloneDialog(
IGitHubServiceProvider gitHubServiceProvider,
IProgress <ServiceProgressData> progress,
CancellationToken cancellationToken,
RepositoryModel repository = null)
{
var dialogService = gitHubServiceProvider.GetService <IDialogService>();
var cloneService = gitHubServiceProvider.GetService <IRepositoryCloneService>();
var usageTracker = gitHubServiceProvider.GetService <IUsageTracker>();
var cloneUrl = repository?.CloneUrl;
if (await dialogService.ShowCloneDialog(null, cloneUrl) is CloneDialogResult result)
{
try
{
await cloneService.CloneOrOpenRepository(result, progress, cancellationToken);
usageTracker.IncrementCounter(x => x.NumberOfStartPageClones).Forget();
return(result);
}
catch
{
var teServices = gitHubServiceProvider.TryGetService <ITeamExplorerServices>();
teServices.ShowError($"Failed to clone the repository '{result.Url.RepositoryName}'");
}
}
return(null);
}
static void SetRepository(IRepositoryCloneTabViewModel vm, RepositoryModel repository)
{
vm.Repository.Returns(repository);
vm.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(
vm,
new PropertyChangedEventArgs(nameof(vm.Repository)));
}
public static async Task <List <RepoItemModel> > getAllRepositoriesAsync(string id)
{
using (var client = new HttpClient())
{
try
{
client.DefaultRequestHeaders.Add("User-Agent", "RepositoryApp");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
Uri uri = new Uri("https://api.github.com/search/repositories?q=" + id);
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; // carrying of SSL access to the API
var response = await client.GetAsync(uri);
string jsonResult = await response.Content.ReadAsStringAsync();
JavaScriptSerializer serializer = new JavaScriptSerializer();
RepositoryModel result = serializer.Deserialize <RepositoryModel>(jsonResult);
return(result.items);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
}
public void set_up()
{
_mockedStorageProvider = new Mock <IStorageProvider>();
_repositoryModel = new RepositoryModel(_mockedStorageProvider.Object);
_controller = new ModulesController(_repositoryModel);
_requestBaseMock = new Mock <HttpRequestBase>();
}
/// <summary>
/// Handles navigation inwards and sets up the repository model parameter.
/// </summary>
public override void PopulateViewModel()
{
RepositoryObject = DV.RepositoryDV.GetModelFromHLink(BaseNavParamsHLink);
if (!(RepositoryObject == null))
{
BaseTitle = RepositoryObject.GetDefaultText;
BaseTitleIcon = CommonConstants.IconRepository;
// Get basic details
CardGroup t = new CardGroup {
Title = "Header Details"
};
t.Add(new CardListLineCollection
{
new CardListLine("Card Type:", "Repository Detail"),
new CardListLine("Name:", RepositoryObject.GRName),
new CardListLine("Type:", RepositoryObject.GType),
});
t.Add(DV.RepositoryDV.GetModelInfoFormatted(RepositoryObject));
BaseDetail.Add(t);
// Add details
BaseDetail.Add(RepositoryObject.GNoteRefCollection.GetCardGroup());
BaseDetail.Add(RepositoryObject.GTagRefCollection.GetCardGroup());
BaseDetail.Add(RepositoryObject.GAddress.GetCardGroup());
BaseDetail.Add(RepositoryObject.GURL);
BaseDetail.Add(RepositoryObject.BackHLinkReferenceCollection.GetCardGroup());
}
}
public IHttpActionResult SaveItemInSession([FromBody] RepositoryModel rep)
{
if (rep != null)
{
if (HttpContext.Current.Session["ListSavedItems"] != null)
{
List <RepositoryModel> itemstemp = new List <RepositoryModel>();
itemstemp = (List <RepositoryModel>)HttpContext.Current.Session["ListSavedItems"];
itemstemp.Add(rep);
HttpContext.Current.Session["ListSavedItems"] = itemstemp;
}
else
{
HttpContext.Current.Session["ListSavedItems"] = new List <RepositoryModel>();;
}
return(Ok());
}
else
{
return(BadRequest());
}
}
public static repository ConvertToRepository(RepositoryModel model)
{
return(new repository()
{
RepositoryName = model.RepositoryName,
});
}
public Repository Create(RepositoryModel model, Int32 uid, out Boolean badName)
{
badName = false;
var repo = Repository.FindByUserIDAndName(uid, model.Name);
if (repo != null)
{
badName = true;
return(null);
}
repo = new Repository
{
Name = model.Name,
Description = model.Description,
UserID = uid,
CreateTime = DateTime.UtcNow,
IsPrivate = model.IsPrivate,
AllowAnonymousRead = model.AllowAnonymousRead,
AllowAnonymousWrite = model.AllowAnonymousWrite,
};
repo.Save();
var ur = new UserRepository();
ur.UserID = uid;
ur.RepositoryID = repo.ID;
ur.IsOwner = true;
ur.Save();
return(repo);
}
public bool Create(RepositoryModel model)
{
if (model == null)
{
throw new ArgumentException("model");
}
if (model.Name == null)
{
throw new ArgumentException("name");
}
using (var database = new BonoboGitServerContext())
{
var repository = new Repository
{
Name = model.Name,
Description = model.Description,
Anonymous = model.AnonymousAccess,
};
database.Repositories.Add(repository);
AddMembers(model.Users, model.Administrators, model.Teams, repository, database);
try
{
database.SaveChanges();
}
catch (UpdateException)
{
return(false);
}
}
return(true);
}
RepositoryModel MakeRepo(string name)
{
var newRepo = new RepositoryModel();
newRepo.Name = name;
return(newRepo);
}
public SqlServerManager(RepositoryModel model)
: base(new SqlServerGenerator(new DapperExtensionsConfiguration(_dataMapper, null, null, new SqlServerDialect())),
new SqlConnection(model.ConnectionString),
new SqlServerDialect())
{
_model = model;
}
/// <summary>
/// Handles navigation inwards and sets up the repository model parameter.
/// </summary>
public override void PopulateViewModel()
{
RepositoryObject = DV.RepositoryDV.GetModelFromHLink(BaseNavParamsHLink);
if (!(RepositoryObject == null))
{
BaseTitle = RepositoryObject.GetDefaultText;
BaseTitleIcon = CommonConstants.IconRepository;
// Trigger refresh of View fields via INotifyPropertyChanged
RaisePropertyChanged(string.Empty);
// Get basic details
//CardGroup t = new CardGroup { Title = "Header Details" };
BaseDetail.Add(new CardListLineCollection
{
new CardListLine("Card Type:", "Repository Detail"),
new CardListLine("Name:", RepositoryObject.GRName),
new CardListLine("Type:", RepositoryObject.GType),
});
BaseDetail.Add(DV.RepositoryDV.GetModelInfoFormatted(RepositoryObject));
//BaseDetail.Add(t);
// Add details
BaseDetail.Add(RepositoryObject.GNoteRefCollection.GetCardGroup());
BaseDetail.Add(RepositoryObject.GTagRefCollection.GetCardGroup());
BaseDetail.Add(RepositoryObject.GAddress.GetCardGroup());
BaseDetail.Add(RepositoryObject.GURL);
}
}
private void CheckForNewRepositories()
{
if (!Directory.Exists(UserConfiguration.Current.Repositories))
{
// We don't want an exception if the repo dir no longer exists,
// as this would make it impossible to start the server
return;
}
IEnumerable <string> directories = Directory.EnumerateDirectories(UserConfiguration.Current.Repositories);
foreach (string directory in directories)
{
string name = Path.GetFileName(directory);
RepositoryModel repository = _repositoryRepository.GetRepository(name);
if (repository == null)
{
if (LibGit2Sharp.Repository.IsValid(directory))
{
repository = new RepositoryModel();
repository.Id = Guid.NewGuid();
repository.Description = "Discovered in file system.";
repository.Name = name;
repository.AnonymousAccess = false;
repository.Users = new UserModel[0];
repository.Teams = new TeamModel[0];
repository.Administrators = new UserModel[0];
if (repository.NameIsValid)
{
_repositoryRepository.Create(repository);
}
}
}
}
}
public PostgreSqlManager(RepositoryModel model)
: base(new PostgreSqlGenerator(new DapperExtensionsConfiguration(_dataMapper, null, null, new PostgreSqlDialect())),
new NpgsqlConnection(model.ConnectionString),
new PostgreSqlDialect())
{
_model = model;
}
/// <summary>
/// The actual Work to be done.
/// </summary>
protected override void Execute()
{
List <RepositoryModel> newlist = new List <RepositoryModel>();
RepositoryModel repositoryModel = new RepositoryModel();
if (this.Request.RepositoryId > 0)
{
repositoryModel = Util.ConvertToRepositoryModel(RepositoryRepository.FirstOrDefault(c => c.Id == this.Request.RepositoryId));
}
else
{
foreach (repository item in RepositoryRepository.GetRepositoriess())
{
newlist.Add(Util.ConvertToRepositoryModel(item));
}
}
Response = new ResponseModel()
{
Repository = repositoryModel,
Repositories = newlist,
IsOperationSuccess = true
};
}
/// <summary>
/// Handles navigation inwards and sets up the repository model parameter.
/// </summary>
public override void HandleViewDataLoadEvent()
{
RepositoryHLink = CommonRoutines.GetHLinkParameter <HLinkRepositoryRefModel>(BaseParamsHLink);
RepositoryObject = RepositoryHLink.DeRef;
if (!(RepositoryObject == null))
{
BaseTitle = RepositoryObject.ToString();
BaseTitleIcon = Constants.IconRepository;
BaseDetail.Add(new CardListLineCollection("Repostiory Ref Detail")
{
new CardListLine("Type:", "Repostiory Ref"),
});
BaseDetail.Add(new CardListLineCollection("Call Details")
{
new CardListLine("Call No:", RepositoryHLink.GCallNo),
new CardListLine("Medium:", RepositoryHLink.GMedium),
});
BaseDetail.Add(RepositoryHLink.DeRef.HLink);
BaseDetail.Add(DV.RepositoryDV.GetModelInfoFormatted(RepositoryObject));
}
}
public ActionResult Create(RepositoryModel model)
{
if (ModelState.IsValid)
{
bool badName;
var repo = RepositoryService.Create(model, Token.UserID, out badName);
if (repo != null)
{
var success = GitService.CreateRepository(model.Name);
if (!success)
{
RepositoryService.Delete(model.Name);
repo = null;
}
}
if (repo != null)
{
return(RedirectToAction("Detail", "Repository", new { name = repo.Name }));
}
if (badName)
{
ModelState.AddModelError("Name", SR.Repository_AlreadyExists);
}
}
return(View(model));
}
public void Update(RepositoryModel model)
{
if (model == null)
{
throw new ArgumentException("model");
}
if (model.Name == null)
{
throw new ArgumentException("name");
}
using (var db = new BonoboGitServerContext())
{
var repo = db.Repositories.FirstOrDefault(i => i.Name == model.Name);
if (repo != null)
{
repo.Description = model.Description;
repo.Anonymous = model.AnonymousAccess;
repo.Users.Clear();
repo.Teams.Clear();
repo.Administrators.Clear();
AddMembers(model.Users, model.Administrators, model.Teams, repo, db);
db.SaveChanges();
}
}
}
public RepositoryModel GetRepositoryModel(string name, bool withShipment = false)
{
using (var ctx = new GitCandyContext())
{
var repo = ctx.Repositories.FirstOrDefault(s => s.Name == name);
if (repo == null)
{
return(null);
}
var model = new RepositoryModel
{
Name = repo.Name,
Description = repo.Description,
IsPrivate = repo.IsPrivate,
AllowAnonymousRead = repo.AllowAnonymousRead,
AllowAnonymousWrite = repo.AllowAnonymousWrite,
};
if (withShipment)
{
model.Collaborators = repo.UserRepositoryRoles
.Select(s => s.User.Name)
.OrderBy(s => s, new StringLogicalComparer())
.ToArray();
model.Teams = repo.TeamRepositoryRoles
.Select(s => s.Team.Name)
.OrderBy(s => s, new StringLogicalComparer())
.ToArray();
}
return(model);
}
}
protected Element CreateElement(RepositoryModel repo)
{
var description = ViewModel.ShowRepositoryDescription ? repo.Description : string.Empty;
var imageUrl = repo.Fork ? Images.GitHubRepoForkUrl : Images.GitHubRepoUrl;
var sse = new RepositoryElement(repo.Name, repo.Watchers, repo.Forks, description, repo.Owner.Login, imageUrl) { ShowOwner = ViewModel.ShowRepositoryOwner };
sse.Tapped += () => ViewModel.GoToRepositoryCommand.Execute(repo);
return sse;
}
private RepositoryDetailStatus GetRepositoryStatus(RepositoryModel model)
{
string path = Path.Combine(UserConfiguration.Current.Repositories, model.Name);
if (!Directory.Exists(path))
return RepositoryDetailStatus.Missing;
else
return RepositoryDetailStatus.Valid;
}
public IObservable <BranchModel> GetBranches(RepositoryModel repo)
{
var keyobs = GetUserFromCache()
.Select(user => string.Format(CultureInfo.InvariantCulture, "{0}|{1}|branch", user.Login, repo.Name));
return(Observable.Defer(() => keyobs
.SelectMany(key => ApiClient.GetBranches(repo.CloneUrl.Owner, repo.CloneUrl.RepositoryName)))
.Select(x => new BranchModel(x.Name, repo)));
}
private static void Init()
{
if (_manager == null)
{
_manager = RepositoryFactory.GetManager();
}
_model = RepositoryFactory.GetModel();
}
public async Task <string> ShowReCloneDialog(RepositoryModel repository)
{
Guard.ArgumentNotNull(repository, nameof(repository));
var viewModel = factory.CreateViewModel <IRepositoryRecloneViewModel>();
viewModel.SelectedRepository = repository;
return((string)await showDialog.ShowWithFirstConnection(viewModel));
}
public ActionResult Repository(RepositoryModel model)
{
if (ModelState.IsValid)
{
repository.SetRepositoryStrategy(model.SelectedOption);
return(RedirectToAction("Index", "Home"));
}
return(PartialView(model));
}
public RepositoryViewModel Init(string repositoryOwner, string repositoryName, RepositoryModel repository = null)
{
RepositoryOwner = repositoryOwner;
RepositoryName = repositoryName;
Repository = repository;
return this;
}
// private void ForkRepository()
// {
// var repoModel = Controller.Model.RepositoryModel;
// var alert = new UIAlertView();
// alert.Title = "Fork".t();
// alert.Message = "What would you like to name your fork?".t();
// alert.AlertViewStyle = UIAlertViewStyle.PlainTextInput;
// var forkButton = alert.AddButton("Fork!".t());
// var cancelButton = alert.AddButton("Cancel".t());
// alert.CancelButtonIndex = cancelButton;
// alert.DismissWithClickedButtonIndex(cancelButton, true);
// alert.GetTextField(0).Text = repoModel.Name;
// alert.Clicked += (object sender2, UIButtonEventArgs e2) => {
// if (e2.ButtonIndex == forkButton)
// {
// var text = alert.GetTextField(0).Text;
// this.DoWork("Forking...".t(), () => {
// //var fork = Application.Client.Users[model.Owner.Login].Repositories[model.Name].Fo(text);
// BeginInvokeOnMainThread(() => {
// // NavigationController.PushViewController(new RepositoryInfoViewController(fork), true);
// });
// }, (ex) => {
// //We typically get a 'BAD REQUEST' but that usually means that a repo with that name already exists
// MonoTouch.Utilities.ShowAlert("Unable to fork".t(), "A repository by that name may already exist in your collection or an internal error has occured.".t());
// });
// }
// };
//
// alert.Show();
// }
public void Render(RepositoryModel model)
{
Title = model.Name;
var root = new RootElement(Title) { UnevenRows = true };
_header.Subtitle = "Updated ".t() + (model.UpdatedAt).ToDaysAgo();
_header.ImageUri = (model.Fork ? Images.GitHubRepoForkUrl : Images.GitHubRepoUrl).AbsoluteUri;
root.Add(new Section(_header));
var sec1 = new Section();
if (!string.IsNullOrEmpty(model.Description) && !string.IsNullOrWhiteSpace(model.Description))
{
var element = new MultilinedElement(model.Description)
{
BackgroundColor = UIColor.White,
CaptionColor = Theme.CurrentTheme.MainTitleColor,
ValueColor = Theme.CurrentTheme.MainTextColor
};
element.CaptionColor = element.ValueColor;
element.CaptionFont = element.ValueFont;
sec1.Add(element);
}
sec1.Add(new SplitElement(new SplitElement.Row {
Text1 = model.Private ? "Private".t() : "Public".t(),
Image1 = model.Private ? Images.Locked : Images.Unlocked,
Text2 = model.Language ?? "N/A",
Image2 = Images.Language
}));
//Calculate the best representation of the size
string size;
if (model.Size / 1024f < 1)
size = string.Format("{0:0.##}KB", model.Size);
else if ((model.Size / 1024f / 1024f) < 1)
size = string.Format("{0:0.##}MB", model.Size / 1024f);
else
size = string.Format("{0:0.##}GB", model.Size / 1024f / 1024f);
sec1.Add(new SplitElement(new SplitElement.Row {
Text1 = model.OpenIssues + (model.OpenIssues == 1 ? " Issue".t() : " Issues".t()),
Image1 = Images.Flag,
Text2 = model.Forks.ToString() + (model.Forks == 1 ? " Fork".t() : " Forks".t()),
Image2 = Images.Fork
}));
sec1.Add(new SplitElement(new SplitElement.Row {
Text1 = (model.CreatedAt).ToString("MM/dd/yy"),
Image1 = Images.Create,
Text2 = size,
Image2 = Images.Size
}));
var owner = new StyledStringElement("Owner".t(), model.Owner.Login) { Image = Images.Person, Accessory = UITableViewCellAccessory.DisclosureIndicator };
owner.Tapped += () => ViewModel.GoToOwnerCommand.Execute(null);
sec1.Add(owner);
if (model.Parent != null)
{
var parent = new StyledStringElement("Forked From".t(), model.Parent.FullName) { Image = Images.Fork, Accessory = UITableViewCellAccessory.DisclosureIndicator };
parent.Tapped += () => ViewModel.GoToForkParentCommand.Execute(model.Parent);
sec1.Add(parent);
}
var followers = new StyledStringElement("Stargazers".t(), "" + model.StargazersCount) { Image = Images.Star, Accessory = UITableViewCellAccessory.DisclosureIndicator };
followers.Tapped += () => ViewModel.GoToStargazersCommand.Execute(null);
sec1.Add(followers);
var events = new StyledStringElement("Events".t(), () => ViewModel.GoToEventsCommand.Execute(null), Images.Event);
var sec2 = new Section { events };
if (model.HasIssues)
sec2.Add(new StyledStringElement("Issues".t(), () => ViewModel.GoToIssuesCommand.Execute(null), Images.Flag));
if (ViewModel.Readme != null)
sec2.Add(new StyledStringElement("Readme".t(), () => ViewModel.GoToReadmeCommand.Execute(null), Images.File));
var sec3 = new Section
{
new StyledStringElement("Commits".t(), () => ViewModel.GoToCommitsCommand.Execute(null), Images.Commit),
new StyledStringElement("Pull Requests".t(), () => ViewModel.GoToPullRequestsCommand.Execute(null), Images.Hand),
new StyledStringElement("Source".t(), () => ViewModel.GoToSourceCommand.Execute(null), Images.Script),
};
root.Add(new[] { sec1, sec2, sec3 });
if (!string.IsNullOrEmpty(model.Homepage))
{
var web = new StyledStringElement("Website".t(), () => ViewModel.GoToUrlCommand.Execute(model.Homepage), Images.Webpage);
root.Add(new Section { web });
}
Root = root;
}
