public T Create(
ContextEnum direction = ContextEnum.Input,
string testName = null,
string folderName = "input",
bool useTransient = true)
{
string suffix = direction == ContextEnum.Expected ? "_out" : "_in";
string testFileName = testName + suffix;
T context = null;
string testFullFileName = null;
if (testFileName != null)
{
testFullFileName = _rootPath + "\\" + folderName + "\\" + testFileName + ".xml";
}
if (useTransient)
{
context = DbContextFactory <T> .Create(testFullFileName);
}
else
{
string connName = typeof(T).FullName + suffix;
context = DbContextFactory <T> .Create(testFullFileName, ConnectionBehaviour.Persistent, connName);
}
return(context);
}
/// <summary>
/// ChangeContentRating
/// </summary>
/// <param name="contentId"></param>
/// <param name="contextId"></param>
/// <param name="rating"></param>
public void ChangeContentRating(int contentId, ContextEnum contextId, int rating)
{
ServiceResponse changeContentRatingResponse = _contentProxy.Execute(opt => opt.ChangeContentRating(contentId,(int)contextId,rating));
if (changeContentRatingResponse.Status != ResponseStatus.Success)
HandleError(changeContentRatingResponse.Status, changeContentRatingResponse.ResponseMessage);
}
private void setModalButtons(ContextEnum c)
{
switch (c)
{
case ContextEnum.GameStart:
nextButtonText.text = "C'est parti !";
nextButton.gameObject.SetActive(true);
break;
case ContextEnum.DiscoveredCard:
nextButtonText.text = "C'est fait !";
nextButton.gameObject.SetActive(true);
break;
case ContextEnum.CardNotFound:
nextButtonText.text = "Ok je réessaye !";
nextButton.gameObject.SetActive(true);
break;
case ContextEnum.EndOfCardStack:
newGameButton.gameObject.SetActive(true);
break;
case ContextEnum.MaxScoreReached:
againButton.gameObject.SetActive(true);
newGameButton.gameObject.SetActive(true);
break;
default:
break;
}
}
/// <summary>
/// ChangeContentVote
/// </summary>
/// <param name="contentId"></param>
/// <param name="contextId"></param>
/// <param name="vote"></param>
public void ChangeContentVote(int contentId, ContextEnum contextId, bool vote)
{
ServiceResponse changeContentVoteResponse = _contentProxy.Execute(opt => opt.ChangeContentVote(contentId,(int)contextId,vote));
if (changeContentVoteResponse.Status != ResponseStatus.Success)
HandleError(changeContentVoteResponse.Status, changeContentVoteResponse.ResponseMessage);
}
public BusyForm(ContextEnum context)
{
InitializeComponent();
// set the current context using the parameter passed from the parent form
currentContext = context;
}
/// <summary>
/// GetUserTasks
/// </summary>
/// <param name="context"></param>
/// <param name="assignedTo"></param>
/// <param name="fromDate"></param>
/// <param name="toDate"></param>
/// <param name="activeTasks"></param>
/// <returns></returns>
public List <UserTaskModel> GetUserTasks(ContextEnum context, string assignedTo, DateTime?fromDate, DateTime?toDate, bool activeTasks)
{
List <UserTaskModel> userTasks = new List <UserTaskModel>();
UserTasksRequestDC userTasksServiceRequest = new UserTasksRequestDC();
userTasksServiceRequest.ContextId = (int)context;
userTasksServiceRequest.AssignedTo = assignedTo;
userTasksServiceRequest.FromDate = fromDate;
userTasksServiceRequest.ToDate = toDate;
userTasksServiceRequest.ActiveTasks = activeTasks;
ServiceResponse <List <UserTaskDC> > userTasksServiceResponse = _workflowProxy.Execute(opt => opt.GetUserTasks(userTasksServiceRequest));
if (userTasksServiceResponse.Status == ResponseStatus.Success)
{
foreach (UserTaskDC userTask in userTasksServiceResponse.Result)
{
userTasks.Add(Mapper.Map <UserTaskDC, UserTaskModel>(userTask));
}
}
else
{
HandleError(userTasksServiceResponse.Status, userTasksServiceResponse.ResponseMessage);
}
return(userTasks);
}
/// <summary>
/// CreateWorkflowTask
/// </summary>
/// <param name="context"></param>
/// <param name="contextId"></param>
/// <param name="taskTitle"></param>
/// <param name="taskDescription"></param>
/// <param name="assignRoleId"></param>
/// <returns></returns>
public UserTask CreateWorkflowTask(ContextEnum contextId, int contextContentId, string taskTitle, string taskDescription)
{
UserTask userTask = eCollabroDbContext.Repository <UserTask>().Query().Filter(qry => qry.SiteId.Equals(UserContextDetails.SiteId) && qry.ContextId.Equals((int)contextId) && qry.ContexContentId.Equals(contextContentId) && qry.IsActive.Equals(true)).Get().FirstOrDefault(); // check if task already created and active
if (userTask == null)
{
userTask = new UserTask();
userTask.CreatedById = UserContextDetails.UserId;
userTask.SiteId = UserContextDetails.SiteId;
userTask.CreatedOn = DateTime.UtcNow;
}
else
{
userTask.ModifiedById = UserContextDetails.UserId;
userTask.ModifiedOn = DateTime.UtcNow;
}
userTask.TaskTitle = taskTitle;
userTask.TaskDescription = taskDescription;
userTask.CompletionPercentage = 0;
userTask.TaskStatus = "New";
userTask.TaskType = "ApproveReject";
userTask.ContextId = (int)contextId;
userTask.IsActive = true;
userTask.ContexContentId = contextContentId;
eCollabroDbContext.Repository <UserTask>().Insert(userTask);
eCollabroDbContext.Save();
return(userTask);
}
/// <summary>
/// GetUserTasks
/// </summary>
/// <returns></returns>
public List <UserTask> GetUserTasks(ContextEnum contextId, string assignedTo, DateTime?fromDate, DateTime?toDate, bool activeTasks)
{
RepositoryQuery <UserTask> userTasks = eCollabroDbContext.Repository <UserTask>().Query().Include(inc => inc.UserMembership).Include(inc => inc.UserMembership1).Filter(qry => qry.SiteId.Equals(UserContextDetails.SiteId));
if (contextId != 0)
{
userTasks = userTasks.Filter(qry => qry.ContextId.Equals((int)contextId));
}
if (!string.IsNullOrEmpty(assignedTo))
{
userTasks = userTasks.Filter(qry => qry.UserMembership.UserName.Equals(assignedTo));
}
if (fromDate.HasValue)
{
DateTime dtFrom = fromDate.Value.ToUniversalTime();
userTasks.Filter(qry => qry.CreatedOn >= dtFrom);
}
if (toDate.HasValue)
{
DateTime dtTo = toDate.Value.ToUniversalTime();
userTasks.Filter(qry => qry.CreatedOn <= dtTo);
}
if (activeTasks)
{
userTasks.Filter(qry => qry.IsActive);
}
SecurityManager securityManager = new SecurityManager();
if ((securityManager.CheckSiteCollectionAdmin(UserContextDetails.UserId) || securityManager.CheckSiteAdmin(UserContextDetails.UserId, UserContextDetails.SiteId)))
{
return(userTasks.Get().ToList());
}
else
{
List <FeaturePermissionResult> userFeaturePermissionResults = eCollabroDbContext.ExtendedRepository().SecurityRepository.GetUserPermissions(UserContextDetails.SiteId, UserContextDetails.UserId).Where(qry => qry.ContentPermissionId.Equals((int)PermissionEnum.ApproveContent)).ToList();
List <int> contentContexts = new List <int>();
if (userFeaturePermissionResults.Count > 0)
{
foreach (FeaturePermissionResult featurePermissionResult in userFeaturePermissionResults)
{
ContextEnum context = GetContextForFeature((FeatureEnum)featurePermissionResult.FeatureId);
if (context != ContextEnum.None)
{
contentContexts.Add((int)context);
}
}
}
if (contentContexts.Count > 0)
{
userTasks = userTasks.Filter(qry => contentContexts.Contains(qry.ContextId) || (qry.AssignedUserId == UserContextDetails.UserId));
}
else
{
userTasks = userTasks.Filter(qry => qry.AssignedUserId.HasValue && qry.AssignedUserId == UserContextDetails.UserId);
}
return(userTasks.Get().ToList());
}
}
/// <summary>
/// ChangeContentRating
/// </summary>
/// <param name="contentId"></param>
/// <param name="contextId"></param>
/// <param name="rating"></param>
public void ChangeContentRating(int contentId, ContextEnum contextId, int rating)
{
ServiceResponse changeContentRatingResponse = _contentProxy.Execute(opt => opt.ChangeContentRating(contentId, (int)contextId, rating));
if (changeContentRatingResponse.Status != ResponseStatus.Success)
{
HandleError(changeContentRatingResponse.Status, changeContentRatingResponse.ResponseMessage);
}
}
/// <summary>
/// ChangeContentVote
/// </summary>
/// <param name="contentId"></param>
/// <param name="contextId"></param>
/// <param name="vote"></param>
public void ChangeContentVote(int contentId, ContextEnum contextId, bool vote)
{
ServiceResponse changeContentVoteResponse = _contentProxy.Execute(opt => opt.ChangeContentVote(contentId, (int)contextId, vote));
if (changeContentVoteResponse.Status != ResponseStatus.Success)
{
HandleError(changeContentVoteResponse.Status, changeContentVoteResponse.ResponseMessage);
}
}
/// <summary>
/// DeleteFromQueue
/// </summary>
/// <param name="context"></param>
/// <param name="contextId"></param>
internal void DeleteFromQueue(ContextEnum context, int contextContentId)
{
ApprovalQueue approvalQueue = eCollabroDbContext.Repository <ApprovalQueue>().Query().Filter(qry => qry.ContextId.Equals((int)context) && qry.ContextContentId.Equals(contextContentId)).Get().FirstOrDefault();
if (approvalQueue != null)
{
eCollabroDbContext.Repository <ApprovalQueue>().Delete(approvalQueue);
}
eCollabroDbContext.Save();
}
/// <summary>
/// GetFromQueue
/// </summary>
/// <typeparam name="TempModel"></typeparam>
/// <param name="context"></param>
/// <param name="contextId"></param>
/// <returns></returns>
internal TempModel GetFromQueue <TempModel>(ContextEnum context, int contextContentId) where TempModel : class
{
ApprovalQueue approvalQueue = eCollabroDbContext.Repository <ApprovalQueue>().Query().Filter(qry => qry.ContextId.Equals((int)context) && qry.ContextContentId.Equals(contextContentId)).Get().FirstOrDefault();
if (approvalQueue != null)
{
return(Desrialize <TempModel>(approvalQueue.ObjectData));
}
return(null);
}
private void showModal(float begining, float startIn)
{
hideCup();
modalPanel.gameObject.SetActive(true);
ContextEnum context = gameState.getContext();
modalMessage(context);
setModalButtons(context);
StartCoroutine(Animations.FadeInCRWithCallBack(begining, startIn, 0.4f, modalPanel.gameObject, onModalAppear));
}
public EFDbContext(ContextEnum test) : base(test.ToString())
{
if (test.Equals(ContextEnum.BeatBuddyTest))
{
Database.SetInitializer<EFDbContext>(new EFDbTestInitializer());
}
else
{
Database.SetInitializer<EFDbContext>(new EFDbInitializer());
}
}
public EFDbContext(ContextEnum test) : base(test.ToString())
{
if (test.Equals(ContextEnum.BeatBuddyTest))
{
Database.SetInitializer <EFDbContext>(new EFDbTestInitializer());
}
else
{
Database.SetInitializer <EFDbContext>(new EFDbInitializer());
}
}
/// <summary>
/// This method add all configurations related to the loading form
/// </summary>
/// <param name="originalForm"></param>
/// <param name="context"></param>
/// <returns></returns>
private static BusyForm ConfigureLoading(Form originalForm, ContextEnum context)
{
return(new BusyForm(context)
{
Size = originalForm.Size,
Left = originalForm.Left,
Top = originalForm.Top,
TopMost = true,
TopLevel = true
});
}
/// <summary>
/// GetFromQueue
/// </summary>
/// <typeparam name="TempModel"></typeparam>
/// <param name="context"></param>
/// <param name="contextIds"></param>
/// <returns></returns>
internal List <TempModel> GetFromQueue <TempModel>(ContextEnum context, List <int> contextContentIds) where TempModel : class
{
List <TempModel> tempModels = new List <TempModel>();
List <ApprovalQueue> approvalQueues = eCollabroDbContext.Repository <ApprovalQueue>().Query().Filter(qry => qry.ContextId.Equals((int)context) && contextContentIds.Contains(qry.ContextContentId)).Get().ToList();
foreach (ApprovalQueue approvalQueue in approvalQueues)
{
tempModels.Add(Desrialize <TempModel>(approvalQueue.ObjectData));
}
return(tempModels);
}
/// <summary>
/// GetUsetTaskComments
/// </summary>
/// <param name="taskId"></param>
/// <returns></returns>
public List <WorkflowComment> GetWorkflowComments(ContextEnum context, int contextContentId)
{
List <WorkflowComment> workflowComments = eCollabroDbContext.Repository <WorkflowComment>().Query().Filter(qry => qry.ContextId.Equals(contextContentId) && qry.ContextId.Equals((int)context)).Get().ToList();
SecurityManager securityManager = new SecurityManager();
List <UserMembership> users = securityManager.GetUsers(workflowComments.Select(fld => fld.CreatedById).ToList());
foreach (WorkflowComment comment in workflowComments)
{
UserMembership user = users.Where(qry => qry.UserId.Equals(comment.CreatedById)).FirstOrDefault();
comment.CreatedBy = user == null ? "Unknown" : user.UserName;
comment.TimeInterval = CommonFunctions.GetTimeInterval(comment.CreatedOn);
}
return(workflowComments);
}
/// <summary>
/// WorkFlowEventHandler
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public IWorkflowEventHandler WorkFlowEventHandler(ContextEnum context)
{
IWorkflowEventHandler workflowEventHandler = null;
if (context.Equals(ContextEnum.Blog) || context.Equals(ContextEnum.Document) || context.Equals(ContextEnum.Image) || context.Equals(ContextEnum.ContentPage))
{
workflowEventHandler = new ContentManager();
}
else
{
return(null);
}
return(workflowEventHandler);
}
/// <summary>
/// SaveToQueue
/// </summary>
/// <typeparam name="TempModel"></typeparam>
/// <param name="model"></param>
/// <param name="context"></param>
/// <param name="contextId"></param>
internal void SaveToQueue <TempModel>(TempModel model, ContextEnum context, int contextContentId)
{
ApprovalQueue approvalQueue = eCollabroDbContext.Repository <ApprovalQueue>().Query().Filter(qry => qry.ContextId.Equals((int)context) && qry.ContextContentId.Equals(contextContentId)).Get().FirstOrDefault();
if (approvalQueue == null)
{
approvalQueue = new ApprovalQueue();
approvalQueue.ContextContentId = contextContentId;
approvalQueue.ContextId = (int)context;
eCollabroDbContext.Repository <ApprovalQueue>().Insert(approvalQueue);
}
approvalQueue.ModifiedById = UserContextDetails.UserId;
approvalQueue.ModifiedOn = DateTime.UtcNow;
approvalQueue.ObjectData = Serialize <TempModel>(model);
eCollabroDbContext.Save();
}
/// <summary>
/// GetContentComments
/// </summary>
/// <param name="contextId"></param>
/// <returns></returns>
public ContentCommentDataModel GetContentComments(ContextEnum context, int contextContentId)
{
ContentCommentDataModel contentCommentsData = null;
ContentCommentRequestDC contentCommentsRequest = new ContentCommentRequestDC();
contentCommentsRequest.ContextId = (int)context;
contentCommentsRequest.ContextContentId = contextContentId;
ServiceResponse <ContentCommentDataDC> contentCommentsResponse = _contentProxy.Execute(opt => opt.GetContentComments(contentCommentsRequest));
if (contentCommentsResponse.Status == ResponseStatus.Success)
{
contentCommentsData = Mapper.Map <ContentCommentDataDC, ContentCommentDataModel>(contentCommentsResponse.Result);
contentCommentsData.ContentComments = new List <ContentCommentModel>();
AddChildContentComments(contentCommentsData.ContentComments, contentCommentsResponse.Result.ContentComments, 0);
}
else
{
HandleError(contentCommentsResponse.Status, contentCommentsResponse.ResponseMessage);
}
return(contentCommentsData);
}
/// <summary>
/// GetUserTaskComments
/// </summary>
/// <returns></returns>
public List <WorkflowCommentModel> GetWorkflowComments(ContextEnum context, int contextContentId)
{
List <WorkflowCommentModel> workflowComments = new List <WorkflowCommentModel>();
WorkflowCommentRequestDC userTaskCommentsServiceRequest = new WorkflowCommentRequestDC();
userTaskCommentsServiceRequest.ContextId = (int)context;
userTaskCommentsServiceRequest.ContextContentId = contextContentId;
ServiceResponse <List <WorkflowCommentDC> > UserTaskCommentsServiceResponse = _workflowProxy.Execute(opt => opt.GetWorkflowComments(userTaskCommentsServiceRequest));
if (UserTaskCommentsServiceResponse.Status == ResponseStatus.Success)
{
foreach (WorkflowCommentDC UserTaskComment in UserTaskCommentsServiceResponse.Result)
{
workflowComments.Add(Mapper.Map <WorkflowCommentDC, WorkflowCommentModel>(UserTaskComment));
}
}
else
{
HandleError(UserTaskCommentsServiceResponse.Status, UserTaskCommentsServiceResponse.ResponseMessage);
}
return(workflowComments);
}
public RenameRegistryKeyAction(ActionRenameRegistryKey actionItem, ContextEnum context)
{
try
{
if (string.IsNullOrEmpty(actionItem.Path) ||
string.IsNullOrEmpty(actionItem.KeyName) ||
string.IsNullOrEmpty(actionItem.NewKeyName))
{
return;
}
Hive = StaticShared.TranslateContextToRegistryHive(context);
Path = StaticShared.GetVersionedString(StaticShared.ResolveSoftware6432Root(actionItem.Path, context));
KeyName = actionItem.KeyName;
NewKeyName = actionItem.NewKeyName;
}
catch (Exception ex)
{
Logger.LogError(ex, "Exception in setting RenameRegistryKeyAction members.");
}
}
private void modalMessage(ContextEnum c)
{
switch (c)
{
case ContextEnum.GameStart:
modalTextTitle.text = "Ça va commencer";
modalTextInfo.text = "Le plus jeune joueur est le premier lecteur. Passe-lui le téléphone.";
break;
case ContextEnum.DiscoveredCard:
modalTextTitle.text = "Bien joué " + gameState.lastPlayerToGuess.name;
modalTextInfo.text = "À son tour de lire, passe-lui le téléphone.";
break;
case ContextEnum.CardNotFound:
modalTextTitle.text = "C'était pourtant facile...";
modalTextInfo.text = "Personne n'a trouvé, fais deviner une autre carte";
break;
case ContextEnum.EndOfCardStack:
modalTextTitle.text = "Félicitations !";
modalTextInfo.text = "Vous avez exploré toutes les cartes de Contrario !";
Player ahead = PlayerPrefManager.aheadPlayer();
if (ahead != null)
{
modalTextInfo.text += " Bravo à " + ahead.name + " qui a le plus haut score !";
}
break;
case ContextEnum.MaxScoreReached:
modalTextTitle.text = gameState.winner.name + " a gagné !";
modalTextInfo.text = "On continue ou on recommence ?";
break;
default:
break;
}
}
public UpdateOptionValueAction(ActionUpdateOptionValue actionItem, ContextEnum context)
{
try
{
if (string.IsNullOrEmpty(actionItem.Name) ||
string.IsNullOrEmpty(actionItem.Type) ||
string.IsNullOrEmpty(actionItem.Value) ||
string.IsNullOrEmpty(actionItem.NewValue))
{
return;
}
Name = actionItem.Name;
Type = actionItem.Type;
Value = actionItem.Value;
NewValue = actionItem.NewValue;
Context = context;
}
catch (Exception ex)
{
Logger.LogError(ex, "Exception in setting UpdateOptionValueAction members.");
}
}
public static string ResolveSoftware6432Root(string path, ContextEnum context)
{
if (!path.Contains("${Software6432}"))
{
return path;
}
if (Environment.Is64BitOperatingSystem &&
context == ContextEnum.Public)
{
return path.Replace("${Software6432}", @"SOFTWARE\Wow6432Node");
}
return path.Replace("${Software6432}", @"SOFTWARE");
}
public static RegistryHive TranslateContextToRegistryHive(ContextEnum context)
{
switch (context)
{
case ContextEnum.Public:
{
return RegistryHive.LocalMachine;
}
case ContextEnum.User:
{
return RegistryHive.CurrentUser;
}
default:
{
throw new Exception("Invalid value");
}
}
}
private bool GetCanRun(ContextEnum context, string optionName)
{
try
{
if (context == ContextEnum.Public)
{
OptionApi.AdminEnter();
bool value = OptionApi.GetBool(optionName);
OptionApi.AdminExit();
return value;
}
if (context == ContextEnum.User)
{
return OptionApi.GetBool(optionName);
}
}
catch (Exception ex)
{
Logger.LogError(ex, "Failed to determine if the upgrade action can run.");
}
return false;
}
/// <summary>
/// ChangeContentLikeDislike
/// </summary>
/// <param name="contentId"></param>
/// <param name="contextId"></param>
/// <param name="liked"></param>
public void ChangeContentLikeDislike(int contentId, ContextEnum contextId, bool liked)
{
ContentLikeDislike contentLikeDislike = eCollabroDbContext.Repository<ContentLikeDislike>().Query().Filter(op => op.CreatedById.Equals(UserContextDetails.UserId)).Get().FirstOrDefault();
if (liked)
{
if (contentLikeDislike == null)
{
contentLikeDislike = new ContentLikeDislike { ContextId = (int)contextId, ContextContentId = contentId, CreatedById = UserContextDetails.UserId, CreatedOn = DateTime.UtcNow, IsLiked = true };
eCollabroDbContext.Repository<ContentLikeDislike>().Insert(contentLikeDislike);
}
else
{
contentLikeDislike.IsLiked = true;
contentLikeDislike.ModifiedById = UserContextDetails.UserId;
contentLikeDislike.ModifiedOn = DateTime.UtcNow;
}
eCollabroDbContext.Save();
}
else
{
if (contentLikeDislike != null)
{
eCollabroDbContext.Repository<ContentLikeDislike>().Delete(contentLikeDislike);
eCollabroDbContext.Save();
}
}
}
/// <summary>
/// This method created a new BsyForm then displays it on top while getting data
/// </summary>
/// <param name="originalForm"></param>
/// <param name="context"></param>
public static void ShowLoading(Form originalForm, ContextEnum context)
{
BusyForm loading = ConfigureLoading(originalForm, context);
loading.ShowDialog(originalForm);
}
/// <summary>
/// GetContentComments
/// </summary>
/// <param name="contextId"></param>
/// <returns></returns>
public ContentCommentDataModel GetContentComments(ContextEnum context, int contextContentId)
{
ContentCommentDataModel contentCommentsData = null;
ContentCommentRequestDC contentCommentsRequest = new ContentCommentRequestDC();
contentCommentsRequest.ContextId = (int)context;
contentCommentsRequest.ContextContentId = contextContentId;
ServiceResponse<ContentCommentDataDC> contentCommentsResponse = _contentProxy.Execute(opt => opt.GetContentComments(contentCommentsRequest));
if (contentCommentsResponse.Status == ResponseStatus.Success)
{
contentCommentsData=Mapper.Map<ContentCommentDataDC, ContentCommentDataModel>(contentCommentsResponse.Result);
contentCommentsData.ContentComments = new List<ContentCommentModel>();
AddChildContentComments(contentCommentsData.ContentComments, contentCommentsResponse.Result.ContentComments, 0);
}
else
{
HandleError(contentCommentsResponse.Status, contentCommentsResponse.ResponseMessage);
}
return contentCommentsData;
}
public HttpResponseMessage ChangeContentVote(int contentId, ContextEnum contextId, bool vote)
{
ContentClientProcessor.ChangeContentVote(contentId, (ContextEnum)contextId, vote);
return(Request.CreateResponse(HttpStatusCode.OK));
}
public HttpResponseMessage ChangeContentRating(int contentId, ContextEnum contextId, int rating)
{
ContentClientProcessor.ChangeContentRating(contentId, (ContextEnum)contextId, rating);
return(Request.CreateResponse(HttpStatusCode.OK));
}
public MigrateOptionsAction(ActionMigrateOptions actionItem,
Dictionary<string, WorkshareUpgradeConfigurationOptionsOption> upgradeConfigurationOptions,
ContextEnum context)
{
try
{
m_workshare5Options = new Dictionary<string, Option>();
foreach (ActionMigrateOptionsFileOptions item in actionItem.FileOptions)
{
string sourcefile = Path.Combine(StaticShared.GetSpecialFolder(item.SourceRoot), item.SourceDirectory, item.SourceFilename);
switch (item.SourceFilename.ToLower())
{
case "options.xml":
{
Logger.LogInfo(string.Format("Load Workshare 5.x Options from the Options.xml file [{0}]", sourcefile));
Workshare5OptionsTranslater.GetOptions(sourcefile, ref m_workshare5Options);
break;
}
case "settings.xml":
{
Logger.LogInfo(string.Format("Load Workshare 5.x Settings from the Settigns.xml file [{0}]", sourcefile));
Workshare5SettingsTranslater.GetSettings(sourcefile, ref m_workshare5Options);
break;
}
default:
{
Logger.LogError( "Only support upgrade from Options or Settings file format");
break;
}
}
}
if (actionItem.RegistryOptions.Length == 1)
{
string sourcefile = Path.Combine(StaticShared.GetSpecialFolder(actionItem.RegistryOptions[0].SourceRoot),
actionItem.RegistryOptions[0].SourceDirectory,
actionItem.RegistryOptions[0].SourceFilename);
Logger.LogInfo(string.Format("Load Workshare 5.x Options from the Registry Export file [{0}]", sourcefile));
RegistryExportTranslater.GetOptions(sourcefile, ref m_workshare5Options);
}
if (!string.IsNullOrEmpty(actionItem.Group))
{
m_upgradeConfigurationOptions = StaticShared.GetGroupOptions(upgradeConfigurationOptions, actionItem.Group);
}
else
{
m_upgradeConfigurationOptions = upgradeConfigurationOptions;
}
m_workshare7Options = Workshare7OptionsTranslater.GetOptions();
m_context = context;
}
catch (Exception ex)
{
Logger.LogError(ex, "Exception in setting MigrateOptionsAction members.");
}
}
private void ExcecuteUpdateOptionValueAction(Action action, ContextEnum context)
{
try
{
if (action == null ||
action.UpdateOptionValue == null)
{
return;
}
foreach (ActionUpdateOptionValue actionItem in action.UpdateOptionValue)
{
if (actionItem == null)
{
return;
}
UpdateOptionValueAction updateOptionValue = new UpdateOptionValueAction(actionItem, context);
updateOptionValue.Execute();
}
}
catch (Exception ex)
{
Logger.LogError(ex);
}
}
private void ExecuteActions(string actionId, ContextEnum context)
{
Logger.LogInfo(string.Format("Executing Action [{0}]", actionId));
Action action = Configuration.Actions[actionId.ToLower()];
ExecuteCopyFileAction(action);
ExecuteRegistryExportAction(action);
ExecuteRegistryCopyAction(action);
ExecuteMigrateOptionsAction(action, context);
ExcecuteRenameRegistryKeyAction(action, context);
ExcecuteUpdateOptionValueAction(action, context);
}
private void SetCanRun(ContextEnum context, string optionName)
{
try
{
if (context == ContextEnum.Public)
{
OptionApi.AdminEnter();
OptionApi.SetBool(optionName, false);
OptionApi.AdminExit();
}
if (context == ContextEnum.User)
{
OptionApi.SetBool(optionName, false);
}
}
catch (Exception ex)
{
Logger.LogError(ex, "Failed to set the upgrade action not to run.");
}
}
/// <summary>
/// ChangeContentRating
/// </summary>
/// <param name="contentId"></param>
/// <param name="contextId"></param>
/// <param name="rating"></param>
public void ChangeContentRating(int contentId, ContextEnum contextId, int rating)
{
ContentRating contentRating = eCollabroDbContext.Repository<ContentRating>().Query().Filter(op => op.CreatedById.Equals(UserContextDetails.UserId)).Get().FirstOrDefault();
if (rating!=0)
{
if (contentRating == null)
{
contentRating = new ContentRating { ContextId = (int)contextId, ContextContentId = contentId, CreatedById = UserContextDetails.UserId, CreatedOn = DateTime.UtcNow, Rating = rating };
eCollabroDbContext.Repository<ContentRating>().Insert(contentRating);
}
else
{
contentRating.Rating = rating;
contentRating.ModifiedById = UserContextDetails.UserId;
contentRating.ModifiedOn = DateTime.UtcNow;
}
eCollabroDbContext.Save();
}
else
{
if (contentRating != null)
{
eCollabroDbContext.Repository<ContentRating>().Delete(contentRating);
eCollabroDbContext.Save();
}
}
}
private void ExcecuteRenameRegistryKeyAction(Action action, ContextEnum context)
{
try
{
if (action == null ||
action.RenameRegistryKey == null)
{
return;
}
foreach (ActionRenameRegistryKey actionItem in action.RenameRegistryKey)
{
if (actionItem == null)
{
return;
}
RenameRegistryKeyAction renameRegistryKey = new RenameRegistryKeyAction(actionItem, context);
renameRegistryKey.Execute();
}
}
catch (Exception ex)
{
Logger.LogError(ex);
}
}
/// <summary>
/// GetContentComment
/// </summary>
/// <param name="contextId"></param>
/// <param name="contextId"></param>
/// <returns></returns>
public ContentCommentData GetContentComments(ContextEnum context, int contextContentId)
{
ContentCommentData contentCommentData = new ContentCommentData();
contentCommentData.ContentComments = eCollabroDbContext.Repository<ContentComment>().Query().Filter(qry => qry.ContextId.Equals((int)context) && qry.ContextContentId.Equals(contextContentId)).Get().ToList();
SecurityManager securityManager = new SecurityManager();
List<UserMembership> users = securityManager.GetUsers(contentCommentData.ContentComments.Select(fld => fld.CreatedById).ToList());
foreach (ContentComment contentComment in contentCommentData.ContentComments)
{
UserMembership user = users.Where(qry => qry.UserId.Equals(contentComment.CreatedById)).FirstOrDefault();
contentComment.CreatedBy = user == null ? "Unknown" : user.UserName;
contentComment.TimeInterval = CommonFunctions.GetTimeInterval(contentComment.CreatedOn);
}
contentCommentData.NumberOfLikes = eCollabroDbContext.Repository<ContentLikeDislike>().Query().Get().Count();
contentCommentData.NumberOfVotes = eCollabroDbContext.Repository<ContentVote>().Query().Get().Count();
int totalRates = eCollabroDbContext.Repository<ContentRating>().Query().Get().Count();
if (totalRates != 0)
contentCommentData.AverageRatings =Math.Round(eCollabroDbContext.Repository<ContentRating>().Query().Get().Sum(op => op.Rating) / totalRates,2);
contentCommentData.UserLiked = eCollabroDbContext.Repository<ContentLikeDislike>().Query().Filter(op => op.CreatedById.Equals(UserContextDetails.UserId)).Get().Any();
ContentRating userRating = eCollabroDbContext.Repository<ContentRating>().Query().Filter(op => op.CreatedById.Equals(UserContextDetails.UserId)).Get().FirstOrDefault();
if (userRating != null)
contentCommentData.UserRating =Convert.ToInt32(userRating.Rating);
contentCommentData.UserVoted = eCollabroDbContext.Repository<ContentVote>().Query().Filter(op => op.CreatedById.Equals(UserContextDetails.UserId)).Get().Any();
return contentCommentData;
}
private void ExecuteMigrateOptionsAction(Action action, ContextEnum context)
{
try
{
if (action == null ||
action.MigrateOptions == null)
{
return;
}
foreach (ActionMigrateOptions actionItem in action.MigrateOptions)
{
if (actionItem == null)
{
return;
}
MigrateOptionsAction migrateOptions = new MigrateOptionsAction(actionItem, Configuration.Options, context);
migrateOptions.Execute();
}
}
catch (Exception ex)
{
Logger.LogError(ex);
}
}
