internal static void ForWorkspace(
WorkspaceInfo wkInfo,
IPlasticAPI plasticApi)
{
if (HasCloudProjectId())
{
return;
}
string repGuid = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
RepositorySpec repSpec = plasticApi.GetRepositorySpec(wkInfo);
RepositoryInfo repInfo = plasticApi.GetRepositoryInfo(repSpec);
repGuid = repInfo.GUID.ToString();
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"SetupCloudProjectId",
waiter.Exception);
}
ConfigureCloudProjectId(repGuid);
});
}
void ExchangeTokensAndJoinOrganization(string unityAccessToken)
{
int ini = Environment.TickCount;
TokenExchangeResponse response = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ResponseInit;
response = PlasticScmRestApiClient.TokenExchange(unityAccessToken);
},
/*afterOperationDelegate*/ delegate
{
mLog.DebugFormat(
"TokenExchange time {0} ms",
Environment.TickCount - ini);
if (waiter.Exception != null)
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorTokenException;
ExceptionsHandler.LogException(
"TokenExchangeSetting",
waiter.Exception);
return;
}
if (response == null)
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorResponseNull;
Debug.Log("response null");
return;
}
if (response.Error != null)
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorResponseError;
mLog.ErrorFormat(
"Unable to exchange token: {0} [code {1}]",
response.Error.Message, response.Error.ErrorCode);
return;
}
if (string.IsNullOrEmpty(response.AccessToken))
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorTokenEmpty;
mLog.InfoFormat(
"Access token is empty for user: {0}",
response.User);
return;
}
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ResponseEnd;
sAccessToken = response.AccessToken;
sUserName = response.User;
GetOrganizationList();
});
}
void InitIgnoreRulesAndRefreshView(
string wkPath, IRefreshableView view)
{
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
AddIgnoreRules.WriteRules(
wkPath, UnityConditions.GetMissingIgnoredRules(wkPath));
},
/*afterOperationDelegate*/ delegate
{
mAreIgnoreRulesInitialized = true;
view.Refresh();
if (waiter.Exception == null)
{
return;
}
mLog.ErrorFormat(
"Error adding ignore rules for Unity: {0}",
waiter.Exception);
mLog.DebugFormat(
"Stack trace: {0}",
waiter.Exception.StackTrace);
});
}
static void InviteMemberButton_clicked(object obj)
{
WorkspaceInfo wkInfo = (WorkspaceInfo)obj;
CurrentUserAdminCheckResponse response = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
waiter.Execute(
/*threadOperationDelegate*/
delegate
{
RepositorySpec repSpec = PlasticGui.Plastic.API.GetRepositorySpec(wkInfo);
ServerProfile serverProfile =
CmConnection.Get().GetProfileManager().GetProfileForServer(repSpec.Server) ??
ClientConfig.Get().GetDefaultProfile();
string authToken = CmConnection.Get()
.BuildWebApiTokenForCloudEditionForProfileAndOrg(
serverProfile);
response = WebRestApiClient.PlasticScm.IsUserAdmin(
ServerOrganizationParser.GetOrganizationFromServer(repSpec.Server),
authToken);
},
/*afterOperationDelegate*/
delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"IsUserAdmin",
waiter.Exception);
return;
}
if (response.Error != null)
{
Debug.LogErrorFormat(
"Error checking if the user is the organization admin: {0}",
string.Format("Unable to get IsUserAdminResponse: {0} [code {1}]",
response.Error.Message,
response.Error.ErrorCode));
return;
}
if (response.IsCurrentUserAdmin)
{
Application.OpenURL("https://www.plasticscm.com/dashboard/cloud/" +
response.OrganizationName +
"/users-and-groups");
return;
}
GuiMessage.ShowInformation(
PlasticLocalization.GetString(PlasticLocalization.Name.InviteMembersTitle),
PlasticLocalization.GetString(PlasticLocalization.Name.InviteMembersMessage));
});
}
internal static void LockInstanceAfterCallout(OperationContext operationContext)
{
if (operationContext != null)
{
InstanceContext instanceContext = operationContext.InstanceContext;
if (operationContext.IsServiceReentrant)
{
ConcurrencyInstanceContextFacet resource = instanceContext.Concurrency;
ThreadWaiter waiter = null;
lock (instanceContext.ThisLock)
{
if (!resource.Locked)
{
resource.Locked = true;
}
else
{
waiter = new ThreadWaiter();
resource.EnqueueCalloutMessage(waiter);
}
}
if (waiter != null)
{
waiter.Wait();
}
}
}
}
void IRefreshableView.Refresh()
{
BranchInfo workingBranch = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
workingBranch = OverlappedCalculator.GetWorkingBranch(
mWkInfo.ClientPath);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
// No need for merge info if it's a label
if (workingBranch == null)
{
return;
}
mMergeController.UpdateMergeObjectInfoIfNeeded(workingBranch);
mMergeViewLogic.Refresh();
});
}
internal static void Run(
bool isGluonMode,
ProgressControlsForViews progressControls)
{
((IProgressControls)progressControls).ShowProgress(string.Empty);
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
Process plasticProcess = LaunchTool.OpenConfigurationForMode(isGluonMode);
if (plasticProcess != null)
{
plasticProcess.WaitForExit();
}
},
/*afterOperationDelegate*/ delegate
{
((IProgressControls)progressControls).HideProgress();
if (waiter.Exception == null)
{
return;
}
((IProgressControls)progressControls).ShowError(
waiter.Exception.Message);
});
}
internal static void ForWorkspace(
WorkspaceInfo wkInfo,
IPlasticAPI plasticApi)
{
RepositoryInfo repInfo = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
RepositorySpec repSpec = plasticApi.GetRepositorySpec(wkInfo);
repInfo = plasticApi.GetRepositoryInfo(repSpec);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"SetupCloudProjectId",
waiter.Exception);
return;
}
SetupCloudProjectId.ForRepository(repInfo);
});
}
void UpdateFileConflictsTree(
IncomingChangesTree incomingChangesTree,
IncomingChangesTreeView incomingChangesTreeView)
{
UnityIncomingChangesTree unityIncomingChangesTree = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
unityIncomingChangesTree = UnityIncomingChangesTree.BuildIncomingChangeCategories(
incomingChangesTree);
incomingChangesTree.ResolveUserNames(
new IncomingChangesTree.ResolveUserName());
},
/*afterOperationDelegate*/ delegate
{
incomingChangesTreeView.BuildModel(unityIncomingChangesTree);
incomingChangesTreeView.Sort();
incomingChangesTreeView.Reload();
incomingChangesTreeView.SelectFirstUnsolvedDirectoryConflict();
});
}
void IAssetMenuOperations.ShowDiff()
{
string selectedPath = AssetsSelection.GetSelectedPath(
mAssetSelection.GetSelectedAssets());
DiffInfo diffInfo = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
string symbolicName = GetSymbolicName(selectedPath);
string extension = Path.GetExtension(selectedPath);
diffInfo = Plastic.API.BuildDiffInfoForDiffWithPrevious(
selectedPath, symbolicName, selectedPath, extension, mWkInfo);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
DiffOperation.DiffWithPrevious(
diffInfo,
null,
null);
});
}
internal static void Initialize()
{
if (mInitialized)
{
return;
}
ConfigureLogging();
RegisterExceptionHandlers();
InitLocalization();
ThreadWaiter.Initialize(new UnityThreadWaiterBuilder());
ServicePointConfigurator.ConfigureServicePoint();
CertificateUi.RegisterHandler(new ChannelCertificateUiImpl());
DisableFsWatcherIfNeeded();
EditionManager.Get().DisableCapability(
EnumEditionCapabilities.Extensions);
ClientHandlers.Register();
PlasticGuiConfig.SetConfigFile(
PlasticGuiConfig.UNITY_GUI_CONFIG_FILE);
mInitialized = true;
}
internal void PartialUpdateWorkspace()
{
mProgressControls.ShowProgress(PlasticLocalization.GetString(
PlasticLocalization.Name.UpdatingWorkspace));
((IUpdateProgress)mGluonProgressOperationHandler).ShowCancelableProgress();
OutOfDateUpdater outOfDateUpdater = new OutOfDateUpdater(mWkInfo);
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
outOfDateUpdater.Execute();
},
/*afterOperationDelegate*/ delegate
{
mProgressControls.HideProgress();
((IUpdateProgress)mGluonProgressOperationHandler).EndProgress();
mViewHost.RefreshView(ViewType.CheckinView);
mViewHost.RefreshView(ViewType.IncomingChangesView);
Refresh.UnityAssetDatabase();
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
ShowUpdateReportDialog(
mWkInfo, mViewHost, outOfDateUpdater.Progress, mProgressControls,
mGuiMessage, mGluonProgressOperationHandler, this);
},
/*timerTickDelegate*/ delegate
{
UpdateProgress progress = outOfDateUpdater.Progress;
if (progress == null)
{
return;
}
if (progress.IsCanceled)
{
mProgressControls.ShowNotification(
PlasticLocalization.GetString(PlasticLocalization.Name.Canceling));
}
((IUpdateProgress)mGluonProgressOperationHandler).RefreshProgress(
progress,
UpdateProgressDataCalculator.CalculateProgressForWorkspaceUpdate(
mWkInfo.ClientPath, progress));
});
}
void FillBranches(WorkspaceInfo wkInfo, string query, List <RepObjectInfo> branchesToSelect)
{
if (mIsRefreshing)
{
return;
}
mIsRefreshing = true;
int defaultRow = TableViewOperations.
GetFirstSelectedRow(mBranchesListView);
((IProgressControls)mProgressControls).ShowProgress(
PlasticLocalization.GetString(
PlasticLocalization.Name.LoadingBranches));
ViewQueryResult queryResult = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
queryResult = new ViewQueryResult(
PlasticGui.Plastic.API.FindQuery(wkInfo, query));
},
/*afterOperationDelegate*/ delegate
{
try
{
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
UpdateBranchesList(
mBranchesListView,
queryResult);
int branchesCount = GetBranchesCount(queryResult);
if (branchesCount == 0)
{
return;
}
BranchesSelection.SelectBranches(
mBranchesListView, branchesToSelect, defaultRow);
}
finally
{
((IProgressControls)mProgressControls).HideProgress();
mIsRefreshing = false;
}
});
}
internal static void InitializeIfNeeded()
{
if (sIsInitialized)
{
return;
}
sIsInitialized = true;
PlasticAPI = new PlasticAPI();
PlasticWebRestApi = new PlasticWebRestApi();
ConfigureLogging();
GuiMessage.Initialize(new UnityPlasticGuiMessage());
RegisterExceptionHandlers();
InitLocalization();
ThreadWaiter.Initialize(new UnityThreadWaiterBuilder());
ServicePointConfigurator.ConfigureServicePoint();
CertificateUi.RegisterHandler(new ChannelCertificateUiImpl());
SetupFsWatcher();
EditionManager.Get().DisableCapability(
EnumEditionCapabilities.Extensions);
ClientHandlers.Register();
PlasticGuiConfig.SetConfigFile(
PlasticGuiConfig.UNITY_GUI_CONFIG_FILE);
sEventSenderScheduler = EventTracking.Configure(
PlasticApp.PlasticWebRestApi,
AssetsPath.IsRunningAsUPMPackage() ?
ApplicationIdentifier.UnityPackage :
ApplicationIdentifier.UnityAssetStorePlugin,
IdentifyEventPlatform.Get());
if (sEventSenderScheduler != null)
{
sPingEventLoop = new PingEventLoop();
sPingEventLoop.Start();
sPingEventLoop.SetUnityVersion(Application.unityVersion);
CollabPlugin.GetVersion(pluginVersion => sPingEventLoop.SetPluginVersion(pluginVersion));
}
PlasticMethodExceptionHandling.InitializeAskCredentialsUi(
new CredentialsUiImpl());
ClientEncryptionServiceProvider.SetEncryptionPasswordProvider(
new MissingEncryptionPasswordPromptHandler());
}
internal static void IfRepositoryIsEmpty(
WorkspaceInfo wkInfo,
string repository,
bool isGluonWorkspace,
IPlasticAPI plasticApi,
IProgressControls progressControls,
ICreateWorkspaceListener createWorkspaceListener,
PlasticWindow plasticWindow)
{
RepositoryInfo repInfo = null;
bool isEmptyRepository = false;
progressControls.ShowProgress(string.Empty);
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
RepositorySpec repSpec = new SpecGenerator().
GenRepositorySpec(false, repository);
repInfo = plasticApi.GetRepositoryInfo(repSpec);
isEmptyRepository = IsEmptyRepositoryCondition.
Evaluate(wkInfo, repSpec, plasticApi);
},
/*afterOperationDelegate*/ delegate
{
progressControls.HideProgress();
if (waiter.Exception != null)
{
DisplayException(progressControls, waiter.Exception);
return;
}
if (!SetupCloudProjectId.HasCloudProjectId())
{
SetupCloudProjectId.ForRepository(repInfo);
}
if (!isEmptyRepository)
{
plasticWindow.RefreshWorkspaceUI();
AssetMenu.AssetMenuItems.Enable();
return;
}
CheckinPackagesAndProjectSettingsFolders(
wkInfo, isGluonWorkspace, plasticApi,
progressControls, createWorkspaceListener);
});
}
internal void ExchangeTokens(string unityAccessToken)
{
int ini = Environment.TickCount;
TokenExchangeResponse response = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
response = PlasticScmRestApiClient.TokenExchange(unityAccessToken);
},
/*afterOperationDelegate*/ delegate
{
mLog.DebugFormat(
"TokenExchange time {0} ms",
Environment.TickCount - ini);
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"TokenExchangeSetting",
waiter.Exception);
return;
}
if (response == null)
{
Debug.Log("response null");
return;
}
if (response.Error != null)
{
mLog.ErrorFormat(
"Unable to exchange token: {0} [code {1}]",
response.Error.Message,
response.Error.ErrorCode);
return;
}
if (string.IsNullOrEmpty(response.AccessToken))
{
mLog.InfoFormat(
"Access token is empty for user: {0}",
response.User);
return;
}
sAccessToken = response.AccessToken;
sUserName = response.User;
});
}
internal static void CheckinPathsPartial(
WorkspaceInfo wkInfo,
List <string> paths,
string comment,
ViewHost viewHost,
CheckinDialog dialog,
GuiMessage.IGuiMessage guiMessage,
IProgressControls progressControls,
IGluonViewSwitcher gluonViewSwitcher)
{
BaseCommandsImpl baseCommands = new BaseCommandsImpl();
progressControls.ShowProgress(PlasticLocalization.GetString(
PlasticLocalization.Name.CheckinInFilesProgress));
IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
baseCommands.PartialCheckin(wkInfo, paths, comment);
},
/*afterOperationDelegate*/ delegate
{
progressControls.HideProgress();
((IPlasticDialogCloser)dialog).CloseDialog();
if (waiter.Exception is CheckinConflictsException)
{
// we need to explicitly call EditorWindow.Close() to ensure
// that the dialog is closed before asking the user
dialog.Close();
if (!UserWantsToShowIncomingView(guiMessage))
{
return;
}
gluonViewSwitcher.ShowIncomingChangesView();
return;
}
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
viewHost.RefreshView(ViewType.CheckinView);
viewHost.RefreshView(ViewType.HistoryView);
});
}
void AsyncCalculateStatus(CancelToken cancelToken)
{
Dictionary <string, LockStatusData> statusByPathCache = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
Dictionary <RepositorySpec, List <WorkspaceTreeNode> > lockCandidates =
new Dictionary <RepositorySpec, List <WorkspaceTreeNode> >();
FillLockCandidates.ForTree(mWkInfo, lockCandidates);
if (cancelToken.IsCancelled())
{
return;
}
Dictionary <WorkspaceTreeNode, LockInfo> lockInfoByNode =
SearchLocks.GetLocksInfo(mWkInfo, lockCandidates);
if (cancelToken.IsCancelled())
{
return;
}
statusByPathCache = BuildStatusByNodeCache.
ForLocks(mWkInfo.ClientPath, lockInfoByNode);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"LockStatusCache",
waiter.Exception);
return;
}
if (cancelToken.IsCancelled())
{
return;
}
lock (mLock)
{
mStatusByPathCache = statusByPathCache;
}
mRepaintProjectWindow();
});
}
void Initialize(PlasticAPI plasticApi, IPlasticWebRestApi plasticWebRestApi)
{
((IProgressControls)mProgressControls).ShowProgress(string.Empty);
WorkspaceInfo[] allWorkspaces = null;
IList allRepositories = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
mDefaultServer = GetDefaultServer.ToCreateWorkspace(plasticWebRestApi);
allWorkspaces = plasticApi.GetAllWorkspacesArray();
allRepositories = plasticApi.GetAllRepositories(
mDefaultServer,
true);
},
/*afterOperationDelegate*/ delegate
{
((IProgressControls)mProgressControls).HideProgress();
if (waiter.Exception != null)
{
DisplayException(mProgressControls, waiter.Exception);
return;
}
string serverSpecPart = string.Format("@{0}", mDefaultServer);
mCreateWorkspaceState.RepositoryName = ValidRepositoryName.Get(
string.Format("{0}{1}",
mCreateWorkspaceState.RepositoryName,
serverSpecPart),
allRepositories);
mCreateWorkspaceState.WorkspaceName =
mCreateWorkspaceState.RepositoryName.Replace(
serverSpecPart,
string.Empty);
mDialogUserAssistant = new CreateWorkspaceDialogUserAssistant(
mWorkspacePath,
allWorkspaces);
OnRepositoryChanged(
mDialogUserAssistant,
mCreateWorkspaceState,
mWorkspacePath);
});
}
void FillData(
MountPointWithPath mountWithPath,
ChangesetInfo csetInfo)
{
mSelectedMountWithPath = mountWithPath;
mSelectedChangesetInfo = csetInfo;
((IProgressControls)mProgressControls).ShowProgress(
PlasticLocalization.GetString(PlasticLocalization.Name.Loading));
mIsSkipMergeTrackingButtonVisible = false;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(100);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
mDiffs = Plastic.API.GetChangesetDifferences(
mountWithPath, csetInfo);
},
/*afterOperationDelegate*/ delegate
{
((IProgressControls)mProgressControls).HideProgress();
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
if (mSelectedMountWithPath != mountWithPath ||
mSelectedChangesetInfo != csetInfo)
{
return;
}
if (mDiffs == null || mDiffs.Count == 0)
{
ClearDiffs();
return;
}
mIsSkipMergeTrackingButtonVisible =
ClientDiffList.HasMerges(mDiffs);
bool skipMergeTracking =
mIsSkipMergeTrackingButtonVisible &&
mIsSkipMergeTrackingButtonChecked;
UpdateDiffTreeView(
mDiffs, skipMergeTracking, mDiffTreeView);
});
}
// These two (ClientHandlers and ThreadWatier) need to be reinitialized if they have not been
// or else an error will be thrown and the Plastic context menu will not show up
internal static void RegisterClientHandlersIfNeeded()
{
if (sIsInitialized)
{
return;
}
ClientHandlers.Register();
ThreadWaiter.Initialize(new UnityThreadWaiterBuilder());
sIsInitialized = true;
}
static void EnableUserBetaProgramIfNeeded(string unityAccessToken)
{
int ini = Environment.TickCount;
UnityPackageBetaEnrollResponse response = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
response = PlasticScmRestApiClient.IsBetaEnabled(unityAccessToken);
},
/*afterOperationDelegate*/ delegate
{
mLog.DebugFormat(
"IsBetaEnabled time {0} ms",
Environment.TickCount - ini);
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"CalculateUserBetaProgramSetting",
waiter.Exception);
return;
}
if (response == null)
{
return;
}
if (response.Error != null)
{
mLog.ErrorFormat(
"Unable to retrieve is beta enabled: {0} [code {1}]",
response.Error.Message, response.Error.ErrorCode);
return;
}
if (!response.IsBetaEnabled)
{
mLog.InfoFormat(
"Beta is disabled for accessToken: {0}",
unityAccessToken);
return;
}
PlasticMenuItem.Add();
});
}
public void AddElement(
string element,
IApplicationWindow window,
IProgressControls progressControls)
{
if (string.IsNullOrEmpty(element))
{
progressControls.ShowError(
Localization.GetText(
Localization.Name.ElementCantBeEmptyErrorMessage));
return;
}
progressControls.ShowProgress(
Localization.GetText(
Localization.Name.AddingElementProgressText,
element));
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
threadOperationDelegate: () =>
{
DoHeavyWork();
if (mModel.Contains(element))
{
throw new Exception(
Localization.GetText(
Localization.Name.ElementInTheListErrorMessage, element));
}
mModel.Add(element);
mModel.Sort(StringComparer.Ordinal);
},
afterOperationDelegate: () =>
{
progressControls.HideProgress();
if (waiter.Exception != null)
{
GuiMessage.ShowError(
Localization.GetText(Localization.Name.ErrorTitle),
waiter.Exception.Message);
return;
}
window.UpdateItems(mModel);
window.ClearInput();
});
}
void OnEnable()
{
if (mException != null)
{
return;
}
GuiMessage.Initialize(new UnityPlasticGuiMessage(this));
ConfigureLogging();
RegisterExceptionHandlers();
RegisterApplicationFocusHandlers(this);
InitLocalization();
ThreadWaiter.Initialize(new UnityThreadWaiterBuilder());
ServicePointConfigurator.ConfigureServicePoint();
CertificateUi.RegisterHandler(new ChannelCertificateUiImpl());
CredentialsUIRegistrar.RegisterCredentialsUI(
new CredentialsUiImpl(this));
ClientEncryptionServiceProvider.SetEncryptionPasswordProvider(
new MissingEncryptionPasswordPromptHandler(this));
DisableFsWatcherIfNeeded();
EditionManager.Get().DisableCapability(
EnumEditionCapabilities.Extensions);
mPlasticAPI = new PlasticAPI();
ClientHandlers.Register();
PlasticGuiConfig.SetConfigFile(PLASTIC_GUI_CONFIG_FILE);
mPingEventLoop = new PingEventLoop();
mEventSenderRestApi = new SimpleEventSenderRestApi(
PlasticWebApiUris.GetBaseUri());
mEventSenderScheduler = EventTracking.Configure(
mEventSenderRestApi,
ApplicationIdentifier.UnityPackage,
IdentifyEventPlatform.Get());
if (mEventSenderScheduler != null)
{
mPingEventLoop.Start();
}
InitializePlastic();
}
static void RunInstaller(
string installerPath,
ProgressControlsForDialogs progressControls,
INotify notify)
{
progressControls.ProgressData.ProgressPercent = -1;
((IProgressControls)progressControls).ShowProgress(
PlasticLocalization.GetString(PlasticLocalization.Name.InstallingProgress));
notify.InstallationStarted();
MacOSConfigWorkaround configWorkaround = new MacOSConfigWorkaround();
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
configWorkaround.CreateClientConfigIfNeeded();
Process installerProcess =
LaunchInstaller.ForPlatform(installerPath);
if (installerProcess != null)
{
installerProcess.WaitForExit();
}
configWorkaround.DeleteClientConfigIfNeeded();
},
/*afterOperationDelegate*/ delegate
{
notify.InstallationFinished();
((IProgressControls)progressControls).HideProgress();
if (waiter.Exception != null)
{
((IProgressControls)progressControls).ShowError(
waiter.Exception.Message);
return;
}
File.Delete(installerPath);
});
}
void AsyncCalculateStatus(CancelToken cancelToken)
{
Dictionary <string, AssetStatus> statusByPathCache = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
OutOfDateItems outOfDateItems =
OutOfDateUpdater.CalculateOutOfDateItems(
mWkInfo, new List <ErrorMessage>(),
OutOfDateCalculator.Options.IsIncomingChanges);
if (cancelToken.IsCancelled())
{
return;
}
statusByPathCache = BuildStatusByPathCache.
ForOutOfDateItems(outOfDateItems, mWkInfo.ClientPath);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"RemoteStatusCache",
waiter.Exception);
return;
}
if (cancelToken.IsCancelled())
{
return;
}
lock (mLock)
{
mStatusByPathCache = statusByPathCache;
}
mRepaintProjectWindow();
});
}
void CreateRepository(
RepositoryCreationData data)
{
if (!data.Result)
{
return;
}
((IProgressControls)mProgressControls).ShowProgress(
PlasticLocalization.GetString(
PlasticLocalization.Name.CreatingRepository,
data.RepName));
RepositoryInfo createdRepository = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
createdRepository = Plastic.API.CreateRepository(
data.ServerName, data.RepName);
},
/*afterOperationDelegate*/ delegate
{
((IProgressControls)mProgressControls).HideProgress();
if (waiter.Exception != null)
{
((IProgressControls)mProgressControls).ShowError(
waiter.Exception.Message);
return;
}
if (createdRepository == null)
{
return;
}
mCreateWorkspaceState.RepositoryName =
createdRepository.GetRepSpec().ToString();
});
}
static void CheckinPackagesAndProjectSettingsFolders(
WorkspaceInfo wkInfo,
bool isGluonWorkspace,
IPlasticAPI plasticApi,
IProgressControls progressControls,
ICreateWorkspaceListener createWorkspaceListener)
{
List <string> paths = new List <string> {
Path.Combine(wkInfo.ClientPath, "Packages"),
Path.Combine(wkInfo.ClientPath, "ProjectSettings")
};
string comment = PlasticLocalization.GetString(
PlasticLocalization.Name.UnityInitialCheckinComment);
progressControls.ShowProgress(PlasticLocalization.GetString(
PlasticLocalization.Name.UnityInitialCheckinProgress));
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
PerformAdd(paths, plasticApi);
PerformCheckinForMode(
wkInfo, paths, comment, isGluonWorkspace);
},
/*afterOperationDelegate*/ delegate
{
progressControls.HideProgress();
if (waiter.Exception != null &&
!IsMergeNeededException(waiter.Exception))
{
DisplayException(progressControls, waiter.Exception);
return;
}
createWorkspaceListener.OnWorkspaceCreated(
wkInfo, isGluonWorkspace);
});
}
void IAssetMenuOperations.ShowDiff()
{
if (LaunchTool.ShowDownloadPlasticExeWindow(
mWkInfo,
mIsGluonMode,
TrackFeatureUseEvent.Features.InstallPlasticCloudFromShowDiff,
TrackFeatureUseEvent.Features.InstallPlasticEnterpriseFromFromShowDiff,
TrackFeatureUseEvent.Features.CancelPlasticInstallationFromFromShowDiff))
{
return;
}
string selectedPath = AssetsSelection.GetSelectedPath(
mAssetSelection.GetSelectedAssets());
DiffInfo diffInfo = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
string symbolicName = GetSymbolicName(selectedPath);
string extension = Path.GetExtension(selectedPath);
diffInfo = PlasticGui.Plastic.API.BuildDiffInfoForDiffWithPrevious(
selectedPath, symbolicName, selectedPath, extension, mWkInfo);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
DiffOperation.DiffWithPrevious(
diffInfo,
null,
null);
});
}
internal static void IfWorkspaceConfigChanged(
IPlasticAPI plasticApi,
WorkspaceInfo lastWkInfo,
bool lastIsGluonMode,
Action reloadAction)
{
string applicationPath = Application.dataPath;
bool isGluonMode = false;
WorkspaceInfo wkInfo = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
wkInfo = FindWorkspace.
InfoForApplicationPath(applicationPath, plasticApi);
if (wkInfo != null)
{
isGluonMode = plasticApi.IsGluonWorkspace(wkInfo);
}
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
return;
}
if (!IsWorkspaceConfigChanged(
lastWkInfo, wkInfo,
lastIsGluonMode, isGluonMode))
{
return;
}
reloadAction();
});
}
internal static void LockInstanceAfterCallout(OperationContext operationContext)
{
if (operationContext != null)
{
InstanceContext instanceContext = operationContext.InstanceContext;
if (operationContext.IsServiceReentrant)
{
ConcurrencyInstanceContextFacet resource = instanceContext.Concurrency;
ThreadWaiter waiter = null;
lock (instanceContext.ThisLock)
{
if (!resource.Locked)
{
resource.Locked = true;
}
else
{
waiter = new ThreadWaiter();
resource.EnqueueCalloutMessage(waiter);
}
}
if (waiter != null)
{
waiter.Wait();
}
}
}
}
