Beispiel #1
0
    public static ReleaseDate Execute(IRepository repo, string commitSha, int calculatedPatch)
    {
        var c = repo.Lookup<Commit>(commitSha);
        Debug.Assert(c != null);

        var rd = new ReleaseDate
                 {
                     OriginalDate = c.When(),
                     OriginalCommitSha = c.Sha,
                     Date = c.When(),
                     CommitSha = c.Sha,
                 };

        if (GitVersionFinder.ShouldGitHubFlowVersioningSchemeApply(repo))
        {
            return rd;
        }

        if (calculatedPatch == 0)
        {
            return rd;
        }

        var vp = new VersionOnMasterFinder().FindLatestStableTaggedCommitReachableFrom(repo, c);
        var latestStable = repo.Lookup<Commit>(vp.CommitSha);
        Debug.Assert(latestStable != null);

        rd.OriginalDate = latestStable.When();
        rd.OriginalCommitSha = vp.CommitSha;
        return rd;
    }
Beispiel #2
0
        private static Patch DiffCommit(IRepository repo, ObjectId oldId, ObjectId newId)
        {
            var commitLeft  = repo.Lookup <Commit>(oldId);
            var commitRight = repo.Lookup <Commit>(newId);

            Console.WriteLine($"正在比对差异 [old]{commitLeft.Message} - [new]{commitRight.Message}");
            var patch = repo.Diff.Compare <Patch>(commitLeft.Tree, commitRight.Tree);

            return(patch);
        }
Beispiel #3
0
        /// <summary>
        /// Try to lookup an object by its <see cref="ObjectId"/>.
        /// </summary>
        /// <typeparam name="T">The kind of <see cref="GitObject"/> to lookup.</typeparam>
        /// <param name="repository">The <see cref="Repository"/> being looked up.</param>
        /// <param name="id">The id.</param>
        /// <returns>The retrieved <see cref="GitObject"/>, or <c>null</c> if none was found.</returns>
        public static T Lookup <T>(this IRepository repository, ObjectId id) where T : GitObject
        {
            EnsureNoGitLink <T>();

            if (typeof(T) == typeof(GitObject))
            {
                return((T)repository.Lookup(id));
            }

            return((T)repository.Lookup(id, GitObject.TypeToKindMap[typeof(T)]));
        }
Beispiel #4
0
        private Task Diff(string filePath)
        {
            // TODO: throw? warn?
            if (string.IsNullOrEmpty(diffTool.Cmd))
            {
                return(Task.CompletedTask);
            }

            var changes = repository.Diff.Compare <TreeChanges>().Modified.First(x => x.Path == filePath);
            var old     = repository.Lookup <Blob>(changes.OldOid);

            // We can't show diff in this case
            if (changes.Mode != Mode.NonExecutableFile || !changes.Exists || old == null || old.IsBinary)
            {
                return(Task.CompletedTask);
            }

            // Write the old content to a temp file for comparison.
            var baseFile = Path.Combine(Path.GetTempPath(), Path.ChangeExtension(Path.GetFileName(filePath), ".BASE" + Path.GetExtension(filePath)));

            File.WriteAllText(baseFile, old.GetContentText());

#pragma warning disable CS8602 // Dereference of a possibly null reference.
            var indexOfDolar = diffTool.Cmd.IndexOf("$");
            if (indexOfDolar == -1)
            {
                // TODO: There were no replacements, so we can't diff anything. Report warning/error?
                return(Task.CompletedTask);
            }

            var indexOfArgs  = diffTool.Cmd.Substring(0, indexOfDolar).LastIndexOf(' ');
            var toolFilePath = diffTool.Cmd.Substring(0, indexOfArgs).Trim();
            var fullFilePath = repository.GetFullPath(filePath);

            // Replace arguments as documented in https://git-scm.com/docs/git-difftool#_options
            var arguments = diffTool.Cmd.Substring(indexOfArgs)
                            // "$LOCAL is set to the name of the temporary file containing the contents of the diff pre-image"
                            .Replace("$LOCAL", baseFile)
                            // "$REMOTE is set to the name of the temporary file containing the contents of the diff post-image"
                            // We want the current file to be the one including the "changes post-image".
                            .Replace("$REMOTE", fullFilePath)
                            // Yes, it's confusing even in the docs that $BASE == $MERGED.
                            // "$MERGED is the name of the file which is being compared.
                            .Replace("$MERGED", fullFilePath)
                            // "$BASE is provided for compatibility with custom merge tool commands and has the same value as $MERGED."
                            .Replace("$BASE", fullFilePath);

#pragma warning restore CS8602 // Dereference of a possibly null reference.

            RunTool(toolFilePath, arguments);

            return(Task.CompletedTask);
        }
Beispiel #5
0
        static string GetMergeBase(IRepository repo, string a, string b)
        {
            var aCommit = repo.Lookup <Commit>(a);
            var bCommit = repo.Lookup <Commit>(b);

            if (aCommit == null || bCommit == null)
            {
                return(null);
            }

            var baseCommit = repo.ObjectDatabase.FindMergeBase(aCommit, bCommit);

            return(baseCommit?.Sha);
        }
        private RebaseStatus CompleteRebase(IRepository r)
        {
            var computeChanges = _computeTreeChangesFactory(_rebase.Repository.Container, _rebase.Repository.RepositoryDescription);
            var previous       = _rebase.StartRepository;
            var lastCommit     = r.Lookup <Commit>(_rebase.RebaseCommitId);

            foreach (var info in _rebase.Transformations.Zip(_rebase.ReplayedCommits, (repository, commit) => (repository, r.Lookup <Commit>(commit))))
            {
                var changes = computeChanges.Compare(previous, info.repository);
                if (changes.Any())
                {
                    var definition = TreeDefinition.From(lastCommit);
                    r.UpdateTreeDefinition(changes, definition, _serializer, lastCommit);
                    var tree = r.ObjectDatabase.CreateTree(definition);
                    previous   = info.repository;
                    lastCommit = r.ObjectDatabase.CreateCommit(info.Item2.Author, info.Item2.Committer, info.Item2.Message, tree, new[] { lastCommit }, false);
                }
            }
            var logMessage = lastCommit.BuildCommitLogMessage(false, false, false);

            r.UpdateHeadAndTerminalReference(lastCommit, logMessage);
            if (_rebase.Repository.Container is ObjectRepositoryContainer container)
            {
                container.ReloadRepository(_rebase.Repository, lastCommit.Id);
            }
            return(RebaseStatus.Complete);
        }
        public Task <byte[]> ExtractFileBinary(IRepository repository, string commitSha, string fileName)
        {
            Guard.ArgumentNotNull(repository, nameof(repository));
            Guard.ArgumentNotEmptyString(commitSha, nameof(commitSha));
            Guard.ArgumentNotEmptyString(fileName, nameof(fileName));

            return(Task.Factory.StartNew(() =>
            {
                var commit = repository.Lookup <Commit>(commitSha);
                if (commit == null)
                {
                    throw new FileNotFoundException("Couldn't find '" + fileName + "' at commit " + commitSha + ".");
                }

                var blob = commit[fileName]?.Target as Blob;

                if (blob != null)
                {
                    using (var m = new MemoryStream())
                    {
                        var content = blob.GetContentStream();
                        content.CopyTo(m);
                        return m.ToArray();
                    }
                }

                return null;
            }));
        }
Beispiel #8
0
        public async Task <IEnumerable <ObjectInventoryItem> > Lookup(ObjectInventoryLookup lookup)
        {
            var defaultDate = new DateTime(2008, 5, 1, 8, 30, 52);

            var result = new List <ObjectInventoryItem>();
            var game   = (await gameRepository.Lookup(lookup.gameLookup)).FirstOrDefault();

            if (game != null && game.Id == 1324)  //stella/bf2142
            {
                if (lookup.DomainId.CompareTo("eagames") == 0 && lookup.SubdomainId.CompareTo("bf2142") == 0 && lookup.PartitionKey.CompareTo("online_content") == 0 && lookup.ObjectIds.Contains("bf2142_bp1"))
                {
                    var entry = new ObjectInventoryItem {
                        ObjectId     = "bf2142_bp1",
                        EditionNo    = 0,
                        DateEntitled = defaultDate,
                        EntitleId    = 114793868,
                        UseCount     = 0
                    };
                    result.Add(entry);

                    entry = new ObjectInventoryItem {
                        ObjectId     = "bf2142_bp1",
                        EditionNo    = 0,
                        DateEntitled = defaultDate,
                        EntitleId    = 245445381,
                        UseCount     = 0
                    };
                    result.Add(entry);
                }
            }

            return((IEnumerable <ObjectInventoryItem>)result);
        }
Beispiel #9
0
        public async Task <string> ExtractFile(IRepository repository, string commitSha, string fileName)
        {
            var commit = repository.Lookup <Commit>(commitSha);
            var blob   = commit[fileName]?.Target as Blob;

            var tempDir      = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            var tempFileName = $"{Path.GetFileNameWithoutExtension(fileName)}@{commitSha}{Path.GetExtension(fileName)}";
            var tempFile     = Path.Combine(tempDir, tempFileName);

            Directory.CreateDirectory(tempDir);

            if (blob != null)
            {
                using (var source = blob.GetContentStream(new FilteringOptions(fileName)))
                    using (var destination = File.OpenWrite(tempFile))
                    {
                        await source.CopyToAsync(destination);
                    }
            }
            else
            {
                File.Create(tempFile).Dispose();
            }

            return(tempFile);
        }
        internal static ObjectRepositoryAdd ComputeChanges_Added(IObjectRepository objectRepository, IObjectRepositorySerializer serializer, IRepository repository, PatchEntryChanges change, Func <string, string> relativeFileDataResolver)
        {
            // Only data file changes have to be taken into account
            // Changes made to the blobs will product a 'modified' change as well
            if (System.IO.Path.GetFileName(change.Path) != FileSystemStorage.DataFile)
            {
                return(null);
            }

            if (objectRepository.TryGetFromGitPath(change.Path) != null)
            {
                throw new NotImplementedException("Node already present in current state.");
            }
            var parentDataPath = change.Path.GetDataParentDataPath();

            if (objectRepository.TryGetFromGitPath(parentDataPath) == null)
            {
                throw new NotImplementedException("Node addition while parent has been deleted in head is not supported.");
            }

            var @new     = serializer.Deserialize(repository.Lookup <Blob>(change.Oid).GetContentStream(), relativeFileDataResolver);
            var parentId = change.Path.GetDataParentId(objectRepository);

            return(new ObjectRepositoryAdd(change.Path, @new, parentId));
        }
Beispiel #11
0
        private static void AssertNormalization(IRepository repo, string filename, bool shouldHaveBeenNormalized, string expectedSha)
        {
            var sb = new StringBuilder();

            sb.Append("I'm going to be dynamically processed\r\n");
            sb.Append("And my line endings...\r\n");
            sb.Append("...are going to be\n");
            sb.Append("normalized!\r\n");

            Touch(repo.Info.WorkingDirectory, filename, sb.ToString());

            repo.Stage(filename);

            IndexEntry entry = repo.Index[filename];

            Assert.NotNull(entry);

            Assert.Equal(expectedSha, entry.Id.Sha);

            var blob = repo.Lookup <Blob>(entry.Id);

            Assert.NotNull(blob);

            Assert.Equal(!shouldHaveBeenNormalized, blob.GetContentText().Contains("\r"));
        }
Beispiel #12
0
        public CommitDetail GetCommitDetails(string sha)
        {
            if (string.IsNullOrEmpty(sha))
            {
                throw new ArgumentNullException();
            }

            var commit = _repository.Lookup <LibGit2Sharp.Commit>(sha);

            if (commit == null)
            {
                throw new CommitNotFoundException(sha);
            }

            var commitParent = commit.Parents.Last();

            TreeChanges treeChanges = _repository.Diff.Compare <TreeChanges>(commitParent.Tree, commit.Tree);

            CommitDetail commitDetail = new CommitDetail(sha, commit.Message, commit.Author.Name, commit.Author.When.Date);

            commitDetail.Files.AddRange(treeChanges.Select(s => new CommitFile((int)s.Status, s.Path, Path.GetFileName(s.Path))));
            //commitDetail.Files.AddRange(treeChanges.Modified.Select(s => new CommitFile((int)s.Status, s.Path, Path.GetFileName(s.Path))));
            //commitDetail.Files.AddRange(treeChanges.Deleted.Select(s => new CommitFile((int)s.Status, s.Path, Path.GetFileName(s.Path))));

            return(commitDetail);
        }
Beispiel #13
0
        public async Task <IEnumerable <Session> > Lookup(SessionLookup lookup)
        {
            var db     = sessionCache.GetDatabase();
            var result = db.HashGet(lookup.sessionKey.ToString(), "guid");
            var ret    = new List <Session>();

            if (!result.HasValue)
            {
                return(ret);
            }
            var session = new Session();

            session.sessionKey = result.ToString();
            var profileId = db.HashGet(lookup.sessionKey.ToString(), "profileid");
            var userId    = db.HashGet(lookup.sessionKey.ToString(), "userid");

            var profileLookup = new ProfileLookup();

            profileLookup.id = int.Parse(profileId.ToString());
            session.profile  = (await profileRepository.Lookup(profileLookup)).FirstOrDefault();

            var userLookup = new UserLookup();

            userLookup.id = int.Parse(userId.ToString());
            session.user  = (await userRepository.Lookup(userLookup)).FirstOrDefault();

            session.appName = db.HashGet(lookup.sessionKey.ToString(), "appName");


            ret.Add(session);

            return(ret);
        }
Beispiel #14
0
        private static Commit LookUpCommit(IRepository repository, string committish)
        {
            GitObject obj = repository.Lookup(committish);

            Ensure.GitObjectIsNotNull(obj, committish);
            return(obj.DereferenceToCommit(true));
        }
Beispiel #15
0
        public Task <byte[]> ExtractFileBinary(IRepository repository, string commitSha, string relativePath)
        {
            Guard.ArgumentNotNull(repository, nameof(repository));
            Guard.ArgumentNotEmptyString(commitSha, nameof(commitSha));
            Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));

            var gitPath = Paths.ToGitPath(relativePath);

            return(Task.Run(() =>
            {
                var commit = repository.Lookup <Commit>(commitSha);
                if (commit == null)
                {
                    throw new FileNotFoundException("Couldn't find '" + gitPath + "' at commit " + commitSha + ".");
                }

                var blob = commit[gitPath]?.Target as Blob;

                if (blob != null)
                {
                    using (var m = new MemoryStream())
                    {
                        var content = blob.GetContentStream();
                        content.CopyTo(m);
                        return m.ToArray();
                    }
                }

                return null;
            }));
        }
        /// <summary>
        /// Inserts a <see cref="LibGit2Sharp.Commit" /> into the object database by applying a <see cref="TreeDefinition"/>.
        /// </summary>
        /// <param name="repository">The repository.</param>
        /// <param name="changes">The changes.</param>
        /// <param name="message">The message.</param>
        /// <param name="author">The author.</param>
        /// <param name="committer">The committer.</param>
        /// <param name="hooks">The hooks.</param>
        /// <param name="options">The options.</param>
        /// <param name="mergeParent">The parent commit for a merge.</param>
        /// <returns>The created <see cref="LibGit2Sharp.Commit" />.</returns>
        internal static Commit CommitChanges(this IRepository repository, MetadataTreeChanges changes, string message, Signature author, Signature committer, GitHooks hooks, CommitOptions options = null, Commit mergeParent = null)
        {
            TreeDefinition definition;

            if (changes.OldRepository?.CommitId != null)
            {
                if (repository.Head.Tip.Id != changes.OldRepository.CommitId)
                {
                    throw new NotSupportedException("Changes are not based on the HEAD commit.");
                }
                var startCommit = repository.Lookup <Commit>(changes.OldRepository.CommitId);
                definition = TreeDefinition.From(startCommit);
            }
            else if (repository.Info.IsHeadUnborn)
            {
                definition = new TreeDefinition();
            }
            else
            {
                throw new NotSupportedException("Changes are not based on the HEAD commit.");
            }

            if (!hooks.OnCommitStarted(changes, message))
            {
                return(null);
            }

            changes.UpdateTreeDefinition(repository, definition);

            var result = Commit(repository, definition, message, author, committer, options, mergeParent);

            hooks.OnCommitCompleted(changes, message, result.Id);

            return(result);
        }
        public async Task <string> GetPullRequestMergeBase(IRepository repo,
                                                           UriString targetCloneUrl, string baseSha, string headSha, string baseRef, int pullNumber)
        {
            Guard.ArgumentNotNull(repo, nameof(repo));
            Guard.ArgumentNotNull(targetCloneUrl, nameof(targetCloneUrl));
            Guard.ArgumentNotEmptyString(baseRef, nameof(baseRef));

            var headCommit = repo.Lookup <Commit>(headSha);

            if (headCommit == null)
            {
                // The PR base branch might no longer exist, so we fetch using `refs/pull/<PR>/head` first.
                // This will often fetch the base commits, even when the base branch no longer exists.
                var headRef = $"refs/pull/{pullNumber}/head";
                await Fetch(repo, targetCloneUrl, headRef);

                headCommit = repo.Lookup <Commit>(headSha);
                if (headCommit == null)
                {
                    throw new NotFoundException($"Couldn't find {headSha} after fetching from {targetCloneUrl}:{headRef}.");
                }
            }

            var baseCommit = repo.Lookup <Commit>(baseSha);

            if (baseCommit == null)
            {
                await Fetch(repo, targetCloneUrl, baseRef);

                baseCommit = repo.Lookup <Commit>(baseSha);
                if (baseCommit == null)
                {
                    throw new NotFoundException($"Couldn't find {baseSha} after fetching from {targetCloneUrl}:{baseRef}.");
                }
            }

            var mergeBaseCommit = repo.ObjectDatabase.FindMergeBase(baseCommit, headCommit);

            if (mergeBaseCommit == null)
            {
                throw new NotFoundException($"Couldn't find merge base between {baseCommit} and {headCommit}.");
            }

            return(mergeBaseCommit.Sha);
        }
        public async Task <Session> GetSession([FromBody] AuthRequest request)
        {
            var lookup = new SessionLookup();

            lookup.sessionKey = request.password;
            var session = (await sessionRepository.Lookup(lookup)).FirstOrDefault();

            return(session);
        }
Beispiel #19
0
        public async Task <AuthResponse> ProfileIDAuth([FromBody] AuthRequest request)
        {
            var sesskey = gs_sesskey(request.session_key);
            var profile = (await profileRepository.Lookup(request.profileLookup)).FirstOrDefault();

            if (profile == null)
            {
                throw new NoSuchUserException();
            }
            var userLookup = new UserLookup();

            userLookup.id = profile.Userid;
            var user = (await userRepository.Lookup(userLookup)).FirstOrDefault();

            if (user == null)
            {
                throw new NoSuchUserException();
            }

            StringBuilder sb = new StringBuilder();

            sb.Append(user.Password);
            sb.Append(sesskey);
            String md5String;

            using (MD5 md5Hash = MD5.Create())
            {
                StringBuilder sBuilder = new StringBuilder();
                byte[]        data     = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()));
                for (int i = 0; i < data.Length; i++)
                {
                    sBuilder.Append(data[i].ToString("x2"));
                }
                md5String = sBuilder.ToString().ToLower();
            }
            if (md5String.Equals(request.client_response.ToLower()))
            {
                var resp = new AuthResponse();
                resp.profile = profile;
                resp.user    = user;
                return(resp);
            }
            throw new AuthInvalidCredentialsException();
        }
Beispiel #20
0
        public async Task <string> GetPullRequestMergeBase(IRepository repo,
                                                           UriString baseCloneUrl, UriString headCloneUrl, string baseSha, string headSha, string baseRef, string headRef)
        {
            Guard.ArgumentNotNull(repo, nameof(repo));
            Guard.ArgumentNotNull(baseCloneUrl, nameof(baseCloneUrl));
            Guard.ArgumentNotNull(headCloneUrl, nameof(headCloneUrl));
            Guard.ArgumentNotEmptyString(baseRef, nameof(baseRef));

            var baseCommit = repo.Lookup <Commit>(baseSha);

            if (baseCommit == null)
            {
                await Fetch(repo, baseCloneUrl, baseRef);

                baseCommit = repo.Lookup <Commit>(baseSha);
                if (baseCommit == null)
                {
                    return(null);
                }
            }

            var headCommit = repo.Lookup <Commit>(headSha);

            if (headCommit == null)
            {
                await Fetch(repo, headCloneUrl, headRef);

                headCommit = repo.Lookup <Commit>(headSha);
                if (headCommit == null)
                {
                    return(null);
                }
            }

            var mergeBaseCommit = repo.ObjectDatabase.FindMergeBase(baseCommit, headCommit);

            if (mergeBaseCommit == null)
            {
                return(null);
            }

            return(mergeBaseCommit.Sha);
        }
Beispiel #21
0
        private async Task <IEnumerable <Commit> > Map(string sha)
        {
            if (!commitMap.ContainsKey(sha))
            {
                // Not in the set to rewrite (that were preloaded)
                return(new[] { repo.Lookup <Commit>(sha) });
            }

            // Wait for it to be rewritten
            var rewritten = await rewrittenMap[sha];

            if (rewritten != null)
            {
                return(new[] { rewritten });
            }

            // It was dropped, so it "becomes" its (rewritten) parents
            return((await commitMap[sha].ConfigureAwait(false)).Parents);
        }
        public async Task PutBlock([FromBody] BuddyLookup lookupData)
        {
            var   from_profile = (await profileRepository.Lookup(lookupData.SourceProfile)).First();
            var   to_profile   = (await profileRepository.Lookup(lookupData.TargetProfile)).First();
            Block block        = new Block();

            block.FromProfileid = from_profile.Id;
            block.ToProfileid   = to_profile.Id;
            await blockRepository.Create(block);

            blockRepository.SendAddEvent(from_profile, to_profile);
        }
Beispiel #23
0
        public async Task <string> GetPullRequestMergeBase(IRepository repo,
                                                           UriString baseCloneUrl, UriString headCloneUrl, string baseSha, string headSha, string baseRef, string headRef)
        {
            Guard.ArgumentNotNull(repo, nameof(repo));
            Guard.ArgumentNotNull(baseCloneUrl, nameof(baseCloneUrl));
            Guard.ArgumentNotNull(headCloneUrl, nameof(headCloneUrl));
            Guard.ArgumentNotEmptyString(baseRef, nameof(baseRef));

            var baseCommit = repo.Lookup <Commit>(baseSha);

            if (baseCommit == null)
            {
                await Fetch(repo, baseCloneUrl, baseRef);

                baseCommit = repo.Lookup <Commit>(baseSha);
                if (baseCommit == null)
                {
                    throw new NotFoundException($"Couldn't find {baseSha} after fetching from {baseCloneUrl}:{baseRef}.");
                }
            }

            var headCommit = repo.Lookup <Commit>(headSha);

            if (headCommit == null)
            {
                await Fetch(repo, headCloneUrl, headRef);

                headCommit = repo.Lookup <Commit>(headSha);
                if (headCommit == null)
                {
                    throw new NotFoundException($"Couldn't find {headSha} after fetching from {headCloneUrl}:{headRef}.");
                }
            }

            var mergeBaseCommit = repo.ObjectDatabase.FindMergeBase(baseCommit, headCommit);

            if (mergeBaseCommit == null)
            {
                throw new NotFoundException($"Couldn't find merge base between {baseCommit} and {headCommit}.");
            }

            return(mergeBaseCommit.Sha);
        }
Beispiel #24
0
        /// <remarks>
        /// While we could easily grab the date while grabbing the interpolated commits,
        /// it would combine two concerns -- e.g. InterpolatedOutDates needs to interpolate also
        /// but does NOT need to know when the commits went in.
        ///
        /// As such, we instead encourage someone with that performance optimization need to
        /// make an IRepository that keeps a list of recently accessed Commits by hash in order
        /// to optimize Lookup{Commit} calls.
        /// </remarks>
        public static IEnumerable <(GitCommitHash changeHash, DateTimeOffset inDate)> GetInDates(
            IEnumerable <GitCommitHash> changes,
            IRepository repository)
        {
            foreach (var commit in changes)
            {
                var c = repository.Lookup <Commit>((string)commit);

                yield return(changeHash : (GitCommitHash)c.Sha, inDate : c.Committer.When);
            }
        }
        Blob GetBlob(string path, string id)
        {
            string sha;

            if (!commitAliases.TryGetValue(id, out sha))
            {
                sha = id;
            }
            var commit = repository.Lookup <Commit>(sha);

            return(commit?[path]?.Target as Blob);
        }
        public async Task <CDKeySuccessResponse> AssociateCDKeyToProfile([FromBody] CDKeyAssociateRequest request)
        {
            var profile = (await profileRepository.Lookup(request.profileLookup)).FirstOrDefault();

            if (profile == null)
            {
                throw new NoSuchUserException();
            }

            var game = (await gameRepository.Lookup(request.gameLookup)).FirstOrDefault();

            if (game == null)
            {
                throw new ArgumentException();
            }


            var profileCdKeyLookup = new CdKeyLookup();

            profileCdKeyLookup.Gameid        = game.Id;
            profileCdKeyLookup.profileLookup = request.profileLookup;

            var cdKeyData = await cdkeyRepository.LookupCDKeyFromProfile(profileCdKeyLookup);

            if (cdKeyData != null)
            {
                throw new CdKeyAlreadySetException();
            }

            var cdkeyLookup = new CdKeyLookup();

            cdkeyLookup.Cdkey  = request.cdkey;
            cdkeyLookup.Gameid = game.Id;

            var resp = new CDKeySuccessResponse();

            resp.success = await cdkeyRepository.AssociateCDKeyToProfile(cdkeyLookup, profile);

            return(resp);
        }
        private Commit ResolveRequiredMigrator(IRepository repository, Commit branchTip, IImmutableList <Migrator> migrators)
        {
            RequiredMigrator = migrators.Count > 0 ? migrators[0] : null;
            if (RequiredMigrator != null && RequiredMigrator.CommitId != MergeCommitId)
            {
                IsPartialMerge = true;

                branchTip     = repository.Lookup <Commit>(RequiredMigrator.CommitId);
                MergeCommitId = RequiredMigrator.CommitId;
            }

            return(branchTip);
        }
Beispiel #28
0
        Commit ResolveRequiredMigrator(IRepository repository, Commit branchTip, System.Collections.Immutable.IImmutableList <Migrator> migrators)
        {
            RequiredMigrator = migrators.Count > 0 ? migrators[0] : null;
            if (RequiredMigrator != null && RequiredMigrator.CommitId != BranchTarget)
            {
                IsPartialMerge = true;

                branchTip    = repository.Lookup <Commit>(RequiredMigrator.CommitId);
                BranchTarget = RequiredMigrator.CommitId;
            }

            return(branchTip);
        }
        private async Task <BsonDocument> getMatchFromLookupRequest(LeaderboardLookup lookup)
        {
            var matchItems = new BsonDocument
            {
            };

            if (lookup.objectId != null)
            {
                matchItems["_id"] = new BsonObjectId(new ObjectId(lookup.objectId));
            }
            else
            {
                var game = (await gameRepository.Lookup(lookup.gameLookup)).FirstOrDefault();
                matchItems["gameid"] = game.Id;
                if (lookup.baseKey != null)
                {
                    matchItems["baseKey"] = lookup.baseKey;
                }
            }

            return(new BsonDocument("$match", matchItems));
        }
Beispiel #30
0
        public async Task <IEnumerable <PersistData> > Lookup(PersistDataLookup lookup)
        {
            var game    = (await gameRepository.Lookup(lookup.gameLookup)).FirstOrDefault();
            var profile = (await profileRepository.Lookup(lookup.profileLookup)).FirstOrDefault();
            var query   = gameTrackerDb.PersistData as IQueryable <PersistData>;

            query = query.Where(s => s.Profileid == profile.Id && s.Gameid == game.Id && s.DataIndex == lookup.DataIndex && s.PersistType == lookup.PersistType);
            if (lookup.modifiedSince.HasValue)
            {
                query = query.Where(s => s.Modified >= lookup.modifiedSince.Value);
            }
            return(await query.ToListAsync());
        }
Beispiel #31
0
        internal DirectReference(string canonicalName, IRepository repo, ObjectId targetId)
            : base(repo, canonicalName, targetId.Sha)
        {
            targetBuilder = new Lazy <GitObject>(() =>
            {
                if (repo == null)
                {
                    throw new InvalidOperationException("Target requires a local repository");
                }

                return(repo.Lookup(targetId));
            });
        }
Beispiel #32
0
        internal DirectReference(string canonicalName, IRepository repo, ObjectId targetId)
            : base(repo, canonicalName, targetId.Sha)
        {
            targetBuilder = new Lazy<GitObject>(() =>
            {
                if (repo == null)
                {
                    throw new InvalidOperationException("Target requires a local repository");
                }

                return repo.Lookup(targetId);
            });
        }
        private static void AssertNormalization(IRepository repo, string filename, bool shouldHaveBeenNormalized, string expectedSha)
        {
            var sb = new StringBuilder();
            sb.Append("I'm going to be dynamically processed\r\n");
            sb.Append("And my line endings...\r\n");
            sb.Append("...are going to be\n");
            sb.Append("normalized!\r\n");

            Touch(repo.Info.WorkingDirectory, filename, sb.ToString());

            repo.Index.Stage(filename);

            IndexEntry entry = repo.Index[filename];
            Assert.NotNull(entry);

            Assert.Equal(expectedSha, entry.Id.Sha);

            var blob = repo.Lookup<Blob>(entry.Id);
            Assert.NotNull(blob);

            Assert.Equal(!shouldHaveBeenNormalized, blob.GetContentText().Contains("\r"));
        }
 internal DirectReference(string canonicalName, IRepository repo, ObjectId targetId)
     : base(canonicalName, targetId.Sha)
 {
     targetBuilder = new Lazy<GitObject>(() => repo.Lookup(targetId));
 }