/// <summary> /// Creates a direct or symbolic reference with the specified name and target /// </summary> /// <param name="name">The name of the reference to create.</param> /// <param name="canonicalRefNameOrObjectish">The target which can be either the canonical name of a reference or a revparse spec.</param> /// <param name="logMessage">The optional message to log in the <see cref="ReflogCollection"/> when adding the <see cref="Reference"/></param> /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param> /// <returns>A new <see cref="Reference"/>.</returns> public virtual Reference Add(string name, string canonicalRefNameOrObjectish, string logMessage, bool allowOverwrite) { Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNullOrEmptyString(canonicalRefNameOrObjectish, "canonicalRefNameOrObjectish"); Reference reference; RefState refState = TryResolveReference(out reference, this, canonicalRefNameOrObjectish); var gitObject = repo.Lookup(canonicalRefNameOrObjectish, GitObjectType.Any, LookUpOptions.None); if (refState == RefState.Exists) { return(Add(name, reference, logMessage, allowOverwrite)); } if (refState == RefState.DoesNotExistButLooksValid && gitObject == null) { using (ReferenceHandle handle = Proxy.git_reference_symbolic_create(repo.Handle, name, canonicalRefNameOrObjectish, allowOverwrite, logMessage)) { return(Reference.BuildFromPtr <Reference>(handle, repo)); } } Ensure.GitObjectIsNotNull(gitObject, canonicalRefNameOrObjectish); if (logMessage == null) { logMessage = string.Format(CultureInfo.InvariantCulture, "{0}: Created from {1}", name.LooksLikeLocalBranch() ? "branch" : "reference", canonicalRefNameOrObjectish); } EnsureHasLog(name); return(Add(name, gitObject.Id, logMessage, allowOverwrite)); }
private Reference UpdateDirectReferenceTarget(Reference directRef, ObjectId targetId, string logMessage) { using (ReferenceHandle referencePtr = RetrieveReferencePtr(directRef.CanonicalName)) using (ReferenceHandle handle = Proxy.git_reference_set_target(referencePtr, targetId, logMessage)) { return(Reference.BuildFromPtr <Reference>(handle, repo)); } }
private Reference UpdateSymbolicRefenceTarget(Reference symbolicRef, Reference targetRef, string logMessage) { using (ReferenceHandle referencePtr = RetrieveReferencePtr(symbolicRef.CanonicalName)) using (ReferenceHandle handle = Proxy.git_reference_symbolic_set_target(referencePtr, targetRef.CanonicalName, logMessage)) { return(Reference.BuildFromPtr <Reference>(handle, repo)); } }
/// <summary> /// Start a rebase operation. /// </summary> /// <param name="branch">The branch to rebase.</param> /// <param name="upstream">The starting commit to rebase.</param> /// <param name="onto">The branch to rebase onto.</param> /// <param name="committer">The <see cref="Identity"/> of who added the change to the repository.</param> /// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param> /// <returns>true if completed successfully, false if conflicts encountered.</returns> public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, Identity committer, RebaseOptions options) { Ensure.ArgumentNotNull(upstream, "upstream"); using (ReferenceHandle branchRefPtr = RefHandleFrom(branch)) using (ReferenceHandle upstreamRefPtr = RefHandleFrom(upstream)) using (ReferenceHandle ontoRefPtr = RefHandleFrom(onto)) return(Start(branchRefPtr, upstreamRefPtr, ontoRefPtr, committer, options)); }
/// <summary> /// Deletes the specified branch. /// </summary> /// <param name="branch">The branch to delete.</param> public virtual void Remove(Branch branch) { Ensure.ArgumentNotNull(branch, "branch"); using (ReferenceHandle referencePtr = repo.Refs.RetrieveReferencePtr(branch.CanonicalName)) { Proxy.git_branch_delete(referencePtr); } }
private static void Set(ReferenceHandle handle, T value) { if (!Storage.ContainsKey(handle)) { throw new ArgumentException($"{typeof(ReferenceProvider<T>)} does not contain handle {handle}"); } Storage[handle] = value; }
private static T Get(ReferenceHandle handle) { if (!Storage.TryGetValue(handle, out var value)) { throw new ArgumentException($"{typeof(ReferenceProvider<T>)} does not contain handle {handle}"); } return(value); }
/// <summary> /// Creates a direct reference with the specified name and target /// </summary> /// <param name="name">The canonical name of the reference to create.</param> /// <param name="targetId">Id of the target object.</param> /// <param name="logMessage">The optional message to log in the <see cref="ReflogCollection"/> when adding the <see cref="DirectReference"/></param> /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param> /// <returns>A new <see cref="Reference"/>.</returns> public virtual DirectReference Add(string name, ObjectId targetId, string logMessage, bool allowOverwrite) { Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(targetId, "targetId"); using (ReferenceHandle handle = Proxy.git_reference_create(repo.Handle, name, targetId, allowOverwrite, logMessage)) { return((DirectReference)Reference.BuildFromPtr <Reference>(handle, repo)); } }
internal T Resolve <T>(string name) where T : Reference { Ensure.ArgumentNotNullOrEmptyString(name, "name"); using (ReferenceHandle referencePtr = RetrieveReferencePtr(name, false)) { return(referencePtr == null ? null : Reference.BuildFromPtr <T>(referencePtr, repo)); } }
internal static ReferenceHandle Register(MessengerImpl messenger, object target, bool weakreference) { var attrs = MessageHandleUtil.GetAttributes(target.GetType()); var handles = new ReferenceHandle[attrs.Length]; for (int i = 0; i < attrs.Length; i++) { var attr = attrs[i]; handles[i] = attr.m_Register(messenger, target, attr, weakreference); } return(new ReferenceHandle(handles)); }
public virtual RebaseResult Start(Commit annotated, Commit upstream, Commit onto, Identity committer, RebaseOptions options) { Ensure.ArgumentNotNull(upstream, "upstream"); // TODO: Rebase does not work with just references, is that a bug or design feature? using (var annotatedRef = ReferenceFrom(annotated)) using (var upstreamRef = ReferenceFrom(upstream)) using (var ontoRef = ReferenceFrom(onto)) using (ReferenceHandle annotatedRefPtr = RefHandleFrom(annotatedRef?.CanonicalName)) using (ReferenceHandle upstreamRefPtr = RefHandleFrom(upstreamRef?.CanonicalName)) using (ReferenceHandle ontoRefPtr = RefHandleFrom(ontoRef?.CanonicalName)) return(Start(annotatedRefPtr, upstreamRefPtr, ontoRefPtr, committer, options)); }
/// <summary> /// Creates a symbolic reference with the specified name and target /// </summary> /// <param name="name">The canonical name of the reference to create.</param> /// <param name="targetRef">The target reference.</param> /// <param name="logMessage">The optional message to log in the <see cref="ReflogCollection"/> when adding the <see cref="SymbolicReference"/></param> /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param> /// <returns>A new <see cref="Reference"/>.</returns> public virtual SymbolicReference Add(string name, Reference targetRef, string logMessage, bool allowOverwrite) { Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(targetRef, "targetRef"); using (ReferenceHandle handle = Proxy.git_reference_symbolic_create(repo.Handle, name, targetRef.CanonicalName, allowOverwrite, logMessage)) { return((SymbolicReference)Reference.BuildFromPtr <Reference>(handle, repo)); } }
/// <summary> /// Start a rebase operation. /// </summary> /// <param name="branch">The branch to rebase.</param> /// <param name="upstream">The starting commit to rebase.</param> /// <param name="onto">The branch to rebase onto.</param> /// <param name="committer">The <see cref="Identity"/> of who added the change to the repository.</param> /// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param> /// <returns>true if completed successfully, false if conflicts encountered.</returns> public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, Identity committer, RebaseOptions options) { Ensure.ArgumentNotNull(upstream, "upstream"); options = options ?? new RebaseOptions(); EnsureNonBareRepo(); if (this.repository.Info.CurrentOperation != CurrentOperation.None) { throw new LibGit2SharpException("A {0} operation is already in progress.", this.repository.Info.CurrentOperation); } Func <Branch, ReferenceHandle> RefHandleFromBranch = (Branch b) => { return((b == null) ? null : this.repository.Refs.RetrieveReferencePtr(b.CanonicalName)); }; using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options)) { GitRebaseOptions gitRebaseOptions = new GitRebaseOptions() { version = 1, checkout_options = checkoutOptionsWrapper.Options, }; using (ReferenceHandle branchRefPtr = RefHandleFromBranch(branch)) using (ReferenceHandle upstreamRefPtr = RefHandleFromBranch(upstream)) using (ReferenceHandle ontoRefPtr = RefHandleFromBranch(onto)) using (AnnotatedCommitHandle annotatedBranchCommitHandle = AnnotatedCommitHandleFromRefHandle(branchRefPtr)) using (AnnotatedCommitHandle upstreamRefAnnotatedCommitHandle = AnnotatedCommitHandleFromRefHandle(upstreamRefPtr)) using (AnnotatedCommitHandle ontoRefAnnotatedCommitHandle = AnnotatedCommitHandleFromRefHandle(ontoRefPtr)) using (RebaseHandle rebaseOperationHandle = Proxy.git_rebase_init(this.repository.Handle, annotatedBranchCommitHandle, upstreamRefAnnotatedCommitHandle, ontoRefAnnotatedCommitHandle, gitRebaseOptions)) { RebaseResult rebaseResult = RebaseOperationImpl.Run(rebaseOperationHandle, this.repository, committer, options); return(rebaseResult); } } }
internal virtual RebaseResult Start(ReferenceHandle annotatedRefPtr, ReferenceHandle upstreamRefPtr, ReferenceHandle ontoRefPtr, Identity committer, RebaseOptions options) { Ensure.ArgumentNotNull(upstreamRefPtr, "upstream"); options = options ?? new RebaseOptions(); EnsureNonBareRepo(); if (this.repository.Info.CurrentOperation != CurrentOperation.None) { throw new LibGit2SharpException("A {0} operation is already in progress.", this.repository.Info.CurrentOperation); } using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options)) { GitRebaseOptions gitRebaseOptions = new GitRebaseOptions() { version = 1, checkout_options = checkoutOptionsWrapper.Options, }; using (AnnotatedCommitHandle annotatedBranchCommitHandle = AnnotatedCommitHandleFromRefHandle(annotatedRefPtr)) using (AnnotatedCommitHandle upstreamRefAnnotatedCommitHandle = AnnotatedCommitHandleFromRefHandle(upstreamRefPtr)) using (AnnotatedCommitHandle ontoRefAnnotatedCommitHandle = AnnotatedCommitHandleFromRefHandle(ontoRefPtr)) using (RebaseHandle rebaseOperationHandle = Proxy.git_rebase_init(this.repository.Handle, annotatedBranchCommitHandle, upstreamRefAnnotatedCommitHandle, ontoRefAnnotatedCommitHandle, gitRebaseOptions)) { this.repository.Submodules.UpdateAll(options.SubmoduleUpdateOptions); RebaseResult rebaseResult = RebaseOperationImpl.Run(rebaseOperationHandle, this.repository, committer, options); return(rebaseResult); } } }
/// <summary> /// Rename an existing local branch /// </summary> /// <param name="branch">The current local branch.</param> /// <param name="newName">The new name the existing branch should bear.</param> /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing branch, false otherwise.</param> /// <returns>A new <see cref="Branch"/>.</returns> public virtual Branch Rename(Branch branch, string newName, bool allowOverwrite) { Ensure.ArgumentNotNull(branch, "branch"); Ensure.ArgumentNotNullOrEmptyString(newName, "newName"); if (branch.IsRemote) { throw new GitException("Cannot rename branch '{0}'. It's a remote tracking branch.", branch.FriendlyName); } using (ReferenceHandle referencePtr = repo.Refs.RetrieveReferencePtr(Reference.LocalBranchPrefix + branch.FriendlyName)) { using (Proxy.git_branch_move(referencePtr, newName, allowOverwrite)) { } } var newBranch = this[newName]; return(newBranch); }
/// <summary> /// Rename an existing reference with a new name, and update the reflog /// </summary> /// <param name="reference">The reference to rename.</param> /// <param name="newName">The new canonical name.</param> /// <param name="logMessage">Message added to the reflog.</param> /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param> /// <returns>A new <see cref="Reference"/>.</returns> public virtual Reference Rename(Reference reference, string newName, string logMessage, bool allowOverwrite) { Ensure.ArgumentNotNull(reference, "reference"); Ensure.ArgumentNotNullOrEmptyString(newName, "newName"); if (logMessage == null) { logMessage = string.Format(CultureInfo.InvariantCulture, "{0}: renamed {1} to {2}", reference.IsLocalBranch ? "branch" : "reference", reference.CanonicalName, newName); } using (ReferenceHandle referencePtr = RetrieveReferencePtr(reference.CanonicalName)) using (ReferenceHandle handle = Proxy.git_reference_rename(referencePtr, newName, allowOverwrite, logMessage)) { return(Reference.BuildFromPtr <Reference>(handle, repo)); } }
public override bool Execute(CommandActivity commandActivity) { //Set templates for FileCase creation. var fileCaseFfTemplateReferenceId = "B475F10A-94ED-4E75-9C64-DF6890569093"; var fileCaseMbTemplateReferenceId = "8087873D-755F-40D4-84C6-1BA7EB8C26AC"; var startFileCases = new List <FileCase>(); try { var hostObject = (File)commandActivity.WorkItem; if (hostObject == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFile .ToLocalizedName() .FormatWith(commandActivity)); } if (!hostObject.CanEdit(true)) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NotEditable .ToLocalizedName() .FormatWith(hostObject)); } //Create FF FileCase var fileCaseTemplateFf = new ReferenceHandle <FileCaseTemplate>(fileCaseFfTemplateReferenceId).GetObject(); if (fileCaseTemplateFf == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCaseTemplate .ToLocalizedName() .FormatWith(fileCaseFfTemplateReferenceId)); } var newTitle = String.Empty; var ffCatalogValue = hostObject.GetProperty("#LHIND_MitberichtExtern_FederfuhrendesAmt") as SpecialdataCatalogValue; if (ffCatalogValue != null) { var ffGroup = ffCatalogValue.GetProperty("#LHIND_MitberichtExtern_Spoc") as TenantGroup; if (ffGroup == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoGroupDefined .ToLocalizedName() .FormatWith(ffCatalogValue)); } var ffFileCase = FileCase.NewObject(hostObject, null, null, fileCaseTemplateFf); ffFileCase.LeadingGroup = ffGroup; newTitle = ffFileCase.GetMultilingualValue(fc => fc.Title) + " - " + ffGroup.GetMultilingualValue(g => g.ShortName); ffFileCase.SetMultilingualValue(fc => fc.Title, newTitle); startFileCases.Add(ffFileCase); } //Create MB FileCases var fileCaseTemplateMb = new ReferenceHandle <FileCaseTemplate>(fileCaseMbTemplateReferenceId).GetObject(); if (fileCaseTemplateMb == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCaseTemplate .ToLocalizedName() .FormatWith(fileCaseMbTemplateReferenceId)); } var mbCatalogValues = hostObject.GetProperty("#LHIND_MitberichtExtern_MitbeteiligtFdListe") as SpecialdataListPropertyValueCollection; foreach (var mbCatalogValue in mbCatalogValues) { var mbGroup = mbCatalogValue.WrappedValue.GetProperty("#LHIND_MitberichtExtern_Spoc") as TenantGroup; if (mbGroup == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoGroupDefined .ToLocalizedName() .FormatWith(ffCatalogValue)); } var mbFileCase = FileCase.NewObject(hostObject, null, null, fileCaseTemplateMb); mbFileCase.LeadingGroup = mbGroup; newTitle = mbFileCase.GetMultilingualValue(fc => fc.Title) + " - " + mbFileCase.LeadingGroup.GetMultilingualValue(g => g.ShortName); mbFileCase.SetMultilingualValue(fc => fc.Title, newTitle); startFileCases.Add(mbFileCase); } ClientTransaction.Current.Commit(); foreach (var startFileCase in startFileCases) { startFileCase.StartObject(); } ClientTransaction.Current.Commit(); } catch (Exception ex) { s_logger.Error(ex.Message, ex); ClientTransaction.Current.Rollback(); throw; } return(true); }
unsafe AnnotatedCommitHandle AnnotatedCommitHandleFromRefHandle(ReferenceHandle refHandle) { return((refHandle == null) ? new AnnotatedCommitHandle(null, false) : Proxy.git_annotated_commit_from_ref(this.repository.Handle, refHandle)); }
public override bool Execute(CommandActivity commandActivity) { const string fileCaseTemplateReferenceId = "04248329-15C8-40C8-8888-90DF1C782A56"; try { var hostObject = (File)commandActivity.WorkItem; if (hostObject == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFile .ToLocalizedName() .FormatWith(commandActivity)); } if (!hostObject.CanEdit(true)) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NotEditable .ToLocalizedName() .FormatWith(hostObject)); } var fileCaseTemplate = new ReferenceHandle <FileCaseTemplate>(fileCaseTemplateReferenceId).GetObject(); if (fileCaseTemplate == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCaseTemplate .ToLocalizedName() .FormatWith(fileCaseTemplateReferenceId)); } var startFileCases = new List <FileCase>(); var fileCaseRecipientGroups = hostObject.GetProperty("#LHIND_Mitbericht_VE_WeiterleitenAn") as SpecialdataListPropertyValueCollection; if (fileCaseRecipientGroups == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoRecipients .ToLocalizedName() .FormatWith(hostObject)); } foreach (var recipientGroup in fileCaseRecipientGroups) { var newFileCase = FileCase.NewObject(hostObject, null, null, fileCaseTemplate); if (newFileCase == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCase .ToLocalizedName() .FormatWith(commandActivity)); } newFileCase.LeadingGroup = recipientGroup.Unwrap() as TenantGroup; var newTitle = hostObject.GetMultilingualValue(fc => fc.Title) + " [" + hostObject.FormattedNumber + "] - " + newFileCase.LeadingGroup.GetMultilingualValue(g => g.ShortName); newFileCase.SetMultilingualValue(fc => fc.Title, newTitle); startFileCases.Add(newFileCase); } ClientTransaction.Current.Commit(); foreach (var startFileCase in startFileCases) { startFileCase.StartObject(); } ClientTransaction.Current.Commit(); } catch (Exception ex) { s_logger.Error(ex.Message, ex); ClientTransaction.Current.Rollback(); throw; } return(true); }
public override bool Execute(CommandActivity commandActivity) { //Set templates for FileCase creation. const string fileCaseFfTemplateReferenceId = "6220CB49-8E09-4AB7-B4F1-673C6C91CC7E"; const string fileCaseMbTemplateReferenceId = "56E01B36-E6DE-4DA3-ABE8-95C6551A76D3"; var startFileCases = new List <FileCase>(); try { var hostObject = (File)commandActivity.WorkItem; if (hostObject == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFile .ToLocalizedName() .FormatWith(commandActivity)); } if (!hostObject.CanEdit(true)) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NotEditable .ToLocalizedName() .FormatWith(hostObject)); } //Create FF FileCase var fileCaseTemplateFf = new ReferenceHandle <FileCaseTemplate>(fileCaseFfTemplateReferenceId).GetObject(); if (fileCaseTemplateFf == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCaseTemplate .ToLocalizedName() .FormatWith(fileCaseFfTemplateReferenceId)); } var newTitle = String.Empty; var ffCatalogValue = hostObject.GetProperty("#LHIND_Mitbericht_FederführendesAmt") as SpecialdataCatalogValue; if (ffCatalogValue != null) { var ffGroup = ffCatalogValue.GetProperty("#LHIND_Mitbericht_Spoc") as TenantGroup; if (ffGroup == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoGroupDefined .ToLocalizedName() .FormatWith(ffCatalogValue)); } var ffFileCase = FileCase.NewObject(hostObject, null, null, fileCaseTemplateFf); ffFileCase.LeadingGroup = ffGroup; newTitle = ffFileCase.GetMultilingualValue(fc => fc.Title) + " - " + ffGroup.GetMultilingualValue(g => g.ShortName); ffFileCase.SetMultilingualValue(fc => fc.Title, newTitle); startFileCases.Add(ffFileCase); } //Create MB FileCases var fileCaseTemplateMb = new ReferenceHandle <FileCaseTemplate>(fileCaseMbTemplateReferenceId).GetObject(); if (fileCaseTemplateMb == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCaseTemplate .ToLocalizedName() .FormatWith(fileCaseMbTemplateReferenceId)); } var mbCatalogValues = hostObject.GetProperty("#LHIND_Mitbericht_MitbeteiligtFdListe") as SpecialdataListPropertyValueCollection; foreach (var mbCatalogValue in mbCatalogValues) { var mbGroup = mbCatalogValue.WrappedValue.GetProperty("#LHIND_Mitbericht_Spoc") as TenantGroup; if (mbGroup == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoGroupDefined .ToLocalizedName() .FormatWith(ffCatalogValue)); } var mbFileCase = FileCase.NewObject(hostObject, null, null, fileCaseTemplateMb); mbFileCase.LeadingGroup = mbGroup; newTitle = mbFileCase.GetMultilingualValue(fc => fc.Title) + " - " + mbFileCase.LeadingGroup.GetMultilingualValue(g => g.ShortName); mbFileCase.SetMultilingualValue(fc => fc.Title, newTitle); startFileCases.Add(mbFileCase); } ClientTransaction.Current.Commit(); foreach (var startFileCase in startFileCases) { startFileCase.StartObject(); } ClientTransaction.Current.Commit(); } catch (Exception ex) { s_logger.Error(ex.Message, ex); ClientTransaction.Current.Rollback(); throw; } return(true); }
internal ReferenceHandle RetrieveReferencePtr(string referenceName, bool shouldThrowIfNotFound = true) { ReferenceHandle reference = Proxy.git_reference_lookup(repo.Handle, referenceName, shouldThrowIfNotFound); return(reference); }
private static void Dispose(ReferenceHandle handle) { Storage.Remove(handle); }
public override bool Execute(CommandActivity commandActivity) { //Set templates for FileCase creation. var fileCaseFfTemplateReferenceId = "F0754977-092B-481B-8A59-AA806FFE1499"; var startFileCases = new List <FileCase>(); try { var hostObject = (File)commandActivity.WorkItem; if (hostObject == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFile .ToLocalizedName() .FormatWith(commandActivity)); } if (!hostObject.CanEdit(true)) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NotEditable .ToLocalizedName() .FormatWith(hostObject)); } //Create FF FileCase var fileCaseTemplateFf = new ReferenceHandle <FileCaseTemplate>(fileCaseFfTemplateReferenceId).GetObject(); if (fileCaseTemplateFf == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCaseTemplate .ToLocalizedName() .FormatWith(fileCaseFfTemplateReferenceId)); } var newTitle = String.Empty; var ffCatalogValue = hostObject.GetProperty("#LHIND_Monatsgespraeche_Federfuehrung") as SpecialdataCatalogValue; if (ffCatalogValue != null) { var ffGroup = ffCatalogValue.GetProperty("#LHIND_Monatsgespraeche_Spoc") as TenantGroup; if (ffGroup == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoGroupDefined .ToLocalizedName() .FormatWith(ffCatalogValue)); } var ffFileCase = FileCase.NewObject(hostObject, null, null, fileCaseTemplateFf); ffFileCase.LeadingGroup = ffGroup; newTitle = ffFileCase.GetMultilingualValue(fc => fc.Title) + " - " + ffGroup.GetMultilingualValue(g => g.ShortName); ffFileCase.SetMultilingualValue(fc => fc.Title, newTitle); startFileCases.Add(ffFileCase); } ClientTransaction.Current.Commit(); foreach (var startFileCase in startFileCases) { startFileCase.StartObject(); } ClientTransaction.Current.Commit(); } catch (Exception ex) { s_logger.Error(ex.Message, ex); ClientTransaction.Current.Rollback(); throw; } return(true); }
public override bool Execute(CommandActivity commandActivity) { //Set templates for FileCase creation. const string fileCaseFfTemplateReferenceId = "9B9A5D57-3DC5-41A6-81DB-6D4ADC1335E6"; const string fileCaseMbTemplateReferenceId = "7AAA0700-CA11-4759-B250-DF3BC05B9754"; var startFileCases = new List <FileCase>(); try { var hostObject = (File)commandActivity.WorkItem; if (hostObject == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFile .ToLocalizedName() .FormatWith(commandActivity)); } if (!hostObject.CanEdit(true)) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NotEditable .ToLocalizedName() .FormatWith(hostObject)); } //Create FF FileCase var fileCaseTemplateFf = new ReferenceHandle <FileCaseTemplate>(fileCaseFfTemplateReferenceId).GetObject(); if (fileCaseTemplateFf == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCaseTemplate .ToLocalizedName() .FormatWith(fileCaseFfTemplateReferenceId)); } var newTitle = String.Empty; var ffGroup = hostObject.GetProperty("#LHIND_Antrag_Ff") as TenantGroup; if (ffGroup != null) { var ffFileCase = FileCase.NewObject(hostObject, null, null, fileCaseTemplateFf); ffFileCase.LeadingGroup = ffGroup; newTitle = ffFileCase.GetMultilingualValue(fc => fc.Title) + " - " + ffGroup.GetMultilingualValue(g => g.ShortName); ffFileCase.SetMultilingualValue(fc => fc.Title, newTitle); startFileCases.Add(ffFileCase); } //Create MB FileCases var fileCaseTemplateMb = new ReferenceHandle <FileCaseTemplate>(fileCaseMbTemplateReferenceId).GetObject(); if (fileCaseTemplateMb == null) { throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.NoFileCaseTemplate .ToLocalizedName() .FormatWith(fileCaseMbTemplateReferenceId)); } var mbFileCaseRecipients = hostObject.GetProperty("#LHIND_Antrag_Mb") as SpecialdataListPropertyValueCollection; foreach (var fileCaseRecipient in mbFileCaseRecipients) { var mbFileCase = FileCase.NewObject(hostObject, null, null, fileCaseTemplateMb); mbFileCase.LeadingGroup = fileCaseRecipient.Unwrap() as TenantGroup; newTitle = mbFileCase.GetMultilingualValue(fc => fc.Title) + " - " + mbFileCase.LeadingGroup.GetMultilingualValue(g => g.ShortName); mbFileCase.SetMultilingualValue(fc => fc.Title, newTitle); startFileCases.Add(mbFileCase); } ClientTransaction.Current.Commit(); foreach (var startFileCase in startFileCases) { startFileCase.StartObject(); } ClientTransaction.Current.Commit(); } catch (Exception ex) { s_logger.Error(ex.Message, ex); ClientTransaction.Current.Rollback(); throw; } return(true); }
// This overload lets public-facing methods avoid having to use the pointers directly internal static unsafe T BuildFromPtr <T>(ReferenceHandle handle, Repository repo) where T : Reference { return(BuildFromPtr <T>((git_reference *)handle.Handle, repo)); }