Esempio n. 1
0
    public void parseFromRecordset(P4RecordSet rs)
    {
        if (rs.HasErrors())
        {
        }

        if (rs.HasWarnings())
        {
            for (int i = 0; i < rs.Warnings.Length; i++)
            {
                string warning = rs.Warnings[i];
                if (warning.Contains("no such file(s)"))
                {
                    mIsFileInPerforce = false;
                }
            }
        }


        if (rs.Records.Length != 0)
        {
            P4Record stat = rs.Records[0];

            //set the bools
            mIsFileInPerforce        = stat["headAction"] != "delete";
            mIsFileLatestRevision    = stat["headRev"] == stat["haveRev"];
            mIsFileCheckedOutByMe    = stat["action"] == "actionOwner";
            mIsFileCheckedOutByOther = stat["otherOpen0"] != null;
        }
    }
Esempio n. 2
0
        /// <summary>
        /// Get the fileState for a single file
        /// </summary>
        /// <param name="vsFileName"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public FileState GetP4FileState(string vsFileName, out string message)
        {
            P4RecordSet recordSet;
            var         p4FileName = GetP4FileName(vsFileName);
            bool        result     = SendCommand("fstat", out message, out recordSet, p4FileName);

            if (!result)
            {
                // Some kind of error. This happens when the file is not under the client's root.
                Log.Debug(string.Format("Not in Perforce (1): {0}", vsFileName));
                return(FileState.NotInPerforce);
            }

            if (recordSet.Records.Length <= 0)
            {
                Log.Debug(string.Format("Not in Perforce (2): {0}", vsFileName));
                return(FileState.NotInPerforce);
            }

            P4Record record    = recordSet[0];
            var      fileState = GetFileStateFromRecordSet(record, out vsFileName);

            Log.Debug(string.Format("Perforce FileState: {0} for {1}", fileState, vsFileName));
            return(fileState);
        }
Esempio n. 3
0
        public void Test001_SetupConnection()
        {
            p4                = new P4Connection();
            p4.Port           = _port;
            p4.CallingProgram = "P4.Net Test Harness";
            p4.CallingVersion = "1.0";
            p4.Connect();

            p4.Client = "TestClient1";
            p4.User   = "******";

            P4Record s = p4.Run("info")[0];

            Assert.AreEqual(s["userName"], "TestUser1", "User name should be known.  This test requires StandardTest to be executed first");
            Assert.AreEqual(s["clientName"], "TestClient1", "Client spec should be known.  This test requires StandardTest to be executed first");
        }
Esempio n. 4
0
        /// <summary>
        /// Decode the Fields in record (returned from fstat for a file).
        /// </summary>
        /// <param name="record">A record returned from fstat for a file</param>
        /// <param name="p4FileName">The P4 fileName for which this record applies</param>
        /// <returns>The FileState for the file</returns>
        private static FileState GetFileStateFromRecordSet(P4Record record, out string p4FileName)
        {
            FieldDictionary fields = record.Fields;

            p4FileName = fields["clientFile"];
            p4FileName = p4FileName.Replace('/', '\\');

            if (fields.ContainsKey("headAction") && fields["headAction"] == "delete")
            {
                return(FileState.DeletedAtHeadRevision);
            }

            if (fields.ContainsKey("ourLock"))
            {
                return(FileState.Locked); // implies also opened for edit
            }

            if (fields.ContainsKey("action"))
            {
                string val = fields["action"];
                if (val == "edit")
                {
                    if (fields.ContainsKey("unresolved"))
                    {
                        return(FileState.NeedsResolved);
                    }

                    if (fields.ContainsKey("haveRev") && fields.ContainsKey("headRev") && fields["haveRev"] != fields["headRev"])
                    {
                        return(FileState.OpenForEditDiffers);
                    }

                    return(FileState.OpenForEdit);
                }

                if (val == "add")
                {
                    if (fields.ContainsKey("movedFile"))
                    {
                        return(FileState.OpenForRenameTarget);
                    }

                    return(FileState.OpenForAdd);
                }

                if (val == "delete")
                {
                    if (fields.ContainsKey("movedFile"))
                    {
                        return(FileState.OpenForRenameSource);
                    }

                    return(FileState.OpenForDelete);
                }

                if (val == "move/delete")
                {
                    return(FileState.OpenForRenameSource);
                }

                if (val == "move/add")
                {
                    return(FileState.OpenForRenameTarget);
                }

                if (val == "integrate")
                {
                    return(FileState.OpenForIntegrate);
                }

                if (val == "branch")
                {
                    return(FileState.OpenForBranch);
                }
            }
            else
            {
                // No action field
                if (fields.ContainsKey("haveRev"))
                {
                    if (fields.ContainsKey("headRev") && fields["haveRev"] == fields["headRev"])
                    {
                        return(FileState.CheckedInHeadRevision);
                    }
                    else
                    {
                        return(FileState.CheckedInPreviousRevision);
                    }
                }
            }

            if (fields.ContainsKey("otherOpen"))
            {
                ArrayFieldDictionary arrayFields = record.ArrayFields;
                if (arrayFields.ContainsKey("otherLock"))
                {
                    return(FileState.LockedByOtherUser);
                }

                if (arrayFields.ContainsKey("otherAction"))
                {
                    string[] array = arrayFields["otherAction"];
                    if (array.Any(val => val == "edit"))
                    {
                        return(FileState.OpenForEditOtherUser);
                    }

                    if (array.Any(val => val == "delete"))
                    {
                        return(FileState.OpenForDeleteOtherUser);
                    }
                }
            }

            return(FileState.NotSet);
        }