private void RegistPan_Click(object sender, EventArgs e)
{
String username = UsernameText.Text;
String password = PasswordText.Text;
String repassword = RePasswordText.Text;
int Sex = 1;
if (Man.Checked)
{
Sex = 1;
}
if (Woman.Checked)
{
Sex = 2;
}
String c = ClassText.Text;
String question = UserQuestion.Text;
String answer = Answer.Text;
if (repassword != password)
{
DialogResult dr = MessageBoxEx.Show(this, "两次密码输入不一致");
RePasswordText.Focus();
}
else if (username == null || "".Equals(username) || password == null || "".Equals(password))
{
DialogResult dr = MessageBoxEx.Show(this, "用户名和密码不能为空");
UsernameText.Focus();
}
else if (question == "请选择或输入密保问题")
{
DialogResult dr = MessageBoxEx.Show(this, "请选择或输入密保问题");
UserQuestion.Focus();
}
else if (answer == null || "".Equals(answer))
{
DialogResult dr = MessageBoxEx.Show(this, "密保答案不能为空");
Answer.Focus();
}
else
{
user u = new user();
u.username = username;
u.password = password;
u.sex = Sex;
u.Class = c;
u.question = question;
u.answer = answer;
userdao ud = new userdao();
if (ud.addUser(u))
{
DialogResult dr = MessageBoxEx.Show(this, "注册成功");
this.Close();
}
else
{
DialogResult dr = MessageBoxEx.Show(this, "注册失败");
}
}
}
public ResultInfoViewModel GetResultInfo(int IdResult)
{
try
{
List <QuestionResultViewModel> resultQuestions = new List <QuestionResultViewModel>();
Result result = Database.Results.Get(IdResult);
if (result.TestPassed != false)
{
foreach (Question question in result.Test.Questions)
{
UserQuestion userQuestion = Database.UserQuestions.Find(x => x.IdQuestion == question.IdQuestion &&
x.IdResult == IdResult).
SingleOrDefault();
resultQuestions.Add(new QuestionResultViewModel(question, userQuestion));
foreach (Answer answer in question.Answers)
{
resultQuestions.LastOrDefault().Answers.Add(new AnswerResultViewModel(answer, userQuestion.UserAnswers.
Where(x => x.IdAnswer == answer.IdAnswer).
SingleOrDefault()));
}
}
return(new ResultInfoViewModel(result, resultQuestions));
}
else
{
return(null);
}
}
catch (Exception e)
{
return(null);
}
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
string password = txtPassword.Text.Trim();
string strSecQuestion = ddlQuestions.SelectedItem.Text;
string strSecAnswer = txtAnswer.Text.Trim();
if (password != "")
{
if (strSecQuestion != "" && strSecAnswer != "")
{
try
{
new UserServiceClient().Using(client =>
{
ReturnObject ro;
bool bIsUserValid = (bool)client.ValidateUser(Session["NCIPL_User"].ToString(), password).ReturnValue;
if (bIsUserValid)
{
//Set questions and answer
UserQuestion[] questions_answer = new UserQuestion[1];
questions_answer[0] = new UserQuestion();
questions_answer[0].QuestionText = strSecQuestion;
questions_answer[0].Answer = strSecAnswer;
ro = client.SetUserQuestionsAndAnswers(Session["NCIPL_User"].ToString(), questions_answer);
divChangePwd.Visible = false;
lblGuamMsg.Visible = false;
lblConfirmation.Text = "Your account has been updated successfully.";
divChangePwdConfirmation.Visible = true;
}
else
{
//do not give auth ticket
ro = client.GetValidationFailureReason(Session["NCIPL_User"].ToString());
//display failure code on login screen
lblGuamMsg.Text = ro.DefaultErrorMessage;
lblGuamMsg.Visible = true;
}
});
}
catch
{
lblGuamMsg.Text = GuamErrorMsg;
lblGuamMsg.Visible = true;
}
}
else
{
lblGuamMsg.Text = "Security Question and Answer are required fields.";
lblGuamMsg.Visible = true;
}
}
else
{
lblGuamMsg.Text = "Please enter Current Password in order to Update Account Information";
lblGuamMsg.Visible = true;
}
}
protected void SaveImageButton_Click(object sender, System.Web.UI.ImageClickEventArgs e)
{
UserQuestion question = (UserQuestion)ViewState["Question"];
question.Type = (UserQuestionType)QuestionTypeRadioButtonList.SelectedIndex;
question.Name = NameTextBox.Text;
if (question.Type == UserQuestionType.FreeAnswer)
{
question.Values.Clear();
UserQuestionOption item = new UserQuestionOption(QuestionTextBox.Text);
question.Values.Add(item);
}
else if (question.Type == UserQuestionType.MultipleChoice)
{
foreach (GridViewRow row in ValuesGridView.Rows)
{
if (row.RowType == DataControlRowType.DataRow)
{
question.Values[row.RowIndex].Value = ((TextBox)row.FindControl("ValueTextBox")).Text;
}
}
question.Values.Add(new UserQuestionOption(QuestionTextBox.Text));
}
if (question.Bvin == string.Empty)
{
MTApp.MembershipServices.UserQuestions.Create(question);
}
else
{
MTApp.MembershipServices.UserQuestions.Update(question);
}
Response.Redirect("~/BVAdmin/People/UserSignupConfig.aspx");
}
public ActionResult <UserQuestion> Post([FromBody] UserQuestonDataTransfer inUserQuestion)
{
if (ModelState.Isvalid)
{
var userQuestion = new UserQuestion
{
Firstname = inUserQuestion.firstname,
Lastname = inUserQuestion.lastname,
Question = inUserQuestion.question,
CategoryId = inUserQuestion.categoryId
};
try
{
// lagre kunden
_context.UserQuestions.Add(userQuestion);
_context.SaveChanges();
return(CreatedAtAction("GetUserQuestion", new { id = userQuestion.Id }, userQuestion));
}
catch (Exception)
{
return(NotFound());
}
}
return(NotFound());
}
//[Authorize(Roles = "Admin")]
public ActionResult Create(FormCollection formCollection)
{
ApplicationDbContext db = new ApplicationDbContext();
UserQuestion userQuestion = new UserQuestion();
userQuestion.SurveyId = Int32.Parse(formCollection["SurveyId"]);
int sqno;
var qCount = (formCollection.Count - 1) / 2;
if (!db.UserQuestion.Any(u => u.SurveyId == userQuestion.SurveyId))
{
sqno = 0;
}
else
{
sqno = (from s in db.UserQuestion
where s.SurveyId == userQuestion.SurveyId
select s.SurveyQuesNo).Max();
}
for (int i = 1; i <= qCount; i++)
{
userQuestion.Question = formCollection["Question" + i];
userQuestion.Type = formCollection["type" + i];
userQuestion.SurveyQuesNo = sqno + i;
db.UserQuestion.Add(userQuestion);//Error handling in both the lines needed
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
public async Task <UserTicketModel> AuthenticateAsync(QuestionAuthModel authModel)
{
List <UserQuestion> userQuestions = (await _unitOfWork
.AuthenticationRepository
.GetUserQuestionsAsync(authModel.UserName)
).ToList();
bool loginFailed = false;
foreach (var questionAnswer in authModel.QuestionAnswers)
{
UserQuestion userQuestion =
userQuestions
.FirstOrDefault(uq => uq.QuestionId == questionAnswer.Id);
if (questionAnswer.Answer != userQuestion.Answer)
{
loginFailed = true;
break;
}
}
if (loginFailed)
{
_unitOfWork.JournalRepository
.AddOperationEntryAsync(
new OperationJournal
{
UserId = userQuestions[0].UserId,
LoginSuccess = false
}
);
await _unitOfWork.Save();
return(new UserTicketModel {
Id = 0
});
}
_unitOfWork.JournalRepository
.AddRegistrationEntryAsync(
new RegistrationJournal
{
UserId = userQuestions[0].UserId
}
);
_unitOfWork.JournalRepository
.AddOperationEntryAsync(
new OperationJournal
{
UserId = userQuestions[0].UserId,
LoginSuccess = true
}
);
await _unitOfWork.Save();
return(new UserTicketModel
{
Id = userQuestions[0].UserId,
UserName = authModel.UserName
});
}
public ActionResult DeleteConfirmed(int id)
{
UserQuestion userQuestion = db.UserQuestion.Find(id);
db.UserQuestion.Remove(userQuestion);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public UserQuestionDTO MapUserQuestionDTO(UserQuestion q)
{
return(new UserQuestionDTO
{
QuestionText = q.QuestionText,
Email = q.Email,
Name = q.Name
});
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
if (QuestionTypeRadioButtonList.SelectedIndex == (int)UserQuestionType.MultipleChoice)
{
UserQuestion question = (UserQuestion)ViewState["Question"];
InitializeGrid(question);
}
}
public QuestionResultViewModel(Question question, UserQuestion userQuestion)
{
IdQuestion = question.IdQuestion;
QuestionText = question.QuestionText;
Score = question.Score;
UserScore = (int)userQuestion.UserScore;
Difficult = question.Difficult;
Answers = new List <AnswerResultViewModel>();
}
public ActionResult Next(SurveyView model)
{
if (!ModelState.IsValid)
{
return(View("Survey", model));
}
foreach (var userQuestionView in model.Questions)
{
UserQuestion userQuestion = new UserQuestion
{
Answer = userQuestionView.Answer,
QuestionId = userQuestionView.QuestionId,
UserId = model.UserId
};
_database.Add(userQuestion);
}
if (!HasOpenQuestions(model.UserId, model.CategoryId))
{
return(RedirectToAction("SurveyCompleted", new { categoryId = model.CategoryId }));
}
var counter = _database.UserQuestions
.Where(uq => uq.Question.CategoryId == model.CategoryId &&
uq.UserId == model.UserId)
.Count();
var remainingQuestions = _database.Questions
.Where(nq => nq.Category.Id == model.CategoryId &&
!_database.UserQuestions
.Where(uq => uq.UserId == model.UserId)
.Select(q => q.QuestionId)
.Contains(nq.Id))
.Take(numberOfQuestions)
.Select(q => new UserQuestionView
{
QuestionId = q.Id,
QuestionDescription = q.Description,
Counter = ++counter
})
.ToList();
var survey = new SurveyView
{
CategoryName = model.CategoryName,
CategoryId = model.CategoryId,
Questions = remainingQuestions,
UserId = model.UserId,
};
ModelState.Clear();
return(View("Survey", survey));
}
//================================================================================================================
//================================================================================================================
#endregion // Properties
#region Constructors
//================================================================================================================
//================================================================================================================
public SiteFooter()
//================================================================================================================
// Default constructor
//================================================================================================================
{
// Create data models for the generic dialogs
PageErrors = new PageErrors();
UserPrompt = new UserPrompt();
UserQuestion = new UserQuestion();
}
public ActionResult ViewQuestion(int id)
{
this.id = id;
CommunityDbContext context = new CommunityDbContext();
ViewBag.Answers = context.Answers.ToList();
UserQuestion question = context.UserQuestions.SingleOrDefault(d => d.QuestionId == id);
return(View(question));
}
protected void NewOptionImageButton_Click(object sender, System.Web.UI.ImageClickEventArgs e)
{
UserQuestion question = (UserQuestion)ViewState["Question"];
UserQuestionOption questionOption = new UserQuestionOption();
questionOption.Bvin = System.Guid.NewGuid().ToString();
question.Values.Add(questionOption);
BindQuestionOptionsGrid(question);
ViewState["Question"] = question;
}
public async Task <ActionResult> DeleteConfirmed(int?id)
{
var user = await GetUser();
UserQuestion userQuestion = db.UserQuestions.Find(user.Id, id);
db.UserQuestions.Remove(userQuestion);
db.SaveChanges();
return(RedirectToAction("Index"));
}
protected void InitializeGrid(UserQuestion question)
{
foreach (GridViewRow row in ValuesGridView.Rows)
{
if (row.RowType == DataControlRowType.DataRow)
{
((TextBox)row.FindControl("ValueTextBox")).Text = question.Values[row.RowIndex].Value;
}
}
}
public ActionResult InsertQuesForUserRegistration(ModelUserRegQuestion mod)
{
using (var transaction = DBC.Database.BeginTransaction())
{
try
{
if (mod == null)
{
throw new Exception("There is no Questionairs to save ");
}
var QuestionObj = new UserQuestion()
{
UQuestion = mod.UQuestion,
FkUQType = mod.FkUQType,
IsStudent = mod.IsStudent,
IsActive = mod.IsActive == null ? true : mod.IsActive,
CreatedOn = DateTime.Now,
CreatedBy = Helper.User.UID
};
DBC.UserQuestions.Add(QuestionObj);
DBC.SaveChanges();
if (mod.FkUQType != 2)
{
var QuestionID = DBC.UserQuestions.Local[0].UQID;
foreach (var item in mod.UserQuestionDetail)
{
var ObjDetail = new UserQuestionDetail()
{
QuesOptionName = item.QuesOptionName,
IsRight = item.IsRight,
IsActive = item.IsActive == null ? true : item.IsActive,
FkQID = QuestionID,
};
DBC.UserQuestionDetails.Add(ObjDetail);
DBC.SaveChanges();
}
}
TempData["success"] = "Question has been created";
transaction.Commit();
return(RedirectToAction("ViewCreateQuesForUserRegistration", "UserRegQuestion"));
}
catch (Exception ex)
{
transaction.Rollback();
ViewData["Error"] = "Error: to Save data " + ex.Message;
return(RedirectToAction("ViewCreateQuesForUserRegistration", "UserRegQuestion"));
}
}
}
public ActionResult AskQuestion(UserQuestion question)
{
question.CategoryId = Convert.ToInt32(Request["Category"]);
CommunityDbContext context = new CommunityDbContext();
question.QuestionDate = DateTime.Now;
// question.Users = Identity.Name;
context.UserQuestions.Add(question);
context.SaveChanges();
return(Redirect("Index"));
}
public ActionResult Edit([Bind(Include = "UQuestionId,SurveyId,SurveyQuesNo,Question,Type")] UserQuestion userQuestion)
{
if (ModelState.IsValid)
{
db.Entry(userQuestion).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.SurveyId = new SelectList(db.Surveys, "SurveyId", "SurveyName", userQuestion.SurveyId);
return(View(userQuestion));
}
public ActionResult CreateQues(UserQuestion u)
{
if (Repositories.CreateQues(u) == true)
{
TempData["success"] = "Your request has been sent to us. We'll get back to you shortly!";
}
else
{
TempData["error"] = "Something went wrong. Please try again!";
}
return(RedirectToAction("Contact"));
}
public ActionResult Edit([Bind(Include = "UserId,QuestionId,Response")] UserQuestion userQuestion)
{
if (ModelState.IsValid)
{
db.Entry(userQuestion).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.QuestionId = new SelectList(db.Questions, "Id", "Text", userQuestion.QuestionId);
ViewBag.UserId = new SelectList(db.Users, "Id", "Email", userQuestion.UserId);
return(View(userQuestion));
}
public async Task <IActionResult> PostQuestion(NewQuestionVM vm, string tags)
{
if (ModelState.IsValid)
{
var user = await OnGetSesstion();
UserQuestion userQuestion = new UserQuestion();
userQuestion.Title = vm.Title;
userQuestion.PostTime = DateTime.Now;
userQuestion.Description = HttpUtility.HtmlEncode(vm.Description);
userQuestion.UserId = user;
_context.UserQuestion.Add(userQuestion);
_context.SaveChanges();
string[] tagArray = tags.Split(',');
foreach (string tag in tagArray)
{
var tagFromDB = _context.SkillTag.Where(x => x.SkillName == tag.ToLower()).SingleOrDefault();
if (tagFromDB == null)
{
SkillTag sktag = new SkillTag
{
ApprovedStatus = false,
SkillName = tag.ToLower(),
TimeApproved = DateTime.Now,
UserId = user
};
_context.SkillTag.Add(sktag);
_context.SaveChanges();
QuestionSkill qs = new QuestionSkill
{
SkillTagId = sktag.SkillTagId,
UserQuestionId = userQuestion.UserQuestionId
};
_context.QuestionSkill.Add(qs);
_context.SaveChanges();
}
else
{
QuestionSkill qs = new QuestionSkill
{
SkillTagId = tagFromDB.SkillTagId,
UserQuestionId = userQuestion.UserQuestionId
};
_context.QuestionSkill.Add(qs);
_context.SaveChanges();
}
}
return(RedirectToAction($"QuestionDetail", new { id = _context.UserQuestion.OrderByDescending(c => c.UserQuestionId).FirstOrDefault().UserQuestionId }));
}
return(View("New", vm));
}
public static bool CreateQues(UserQuestion q)
{
NGOEntities e = new NGOEntities();
q.QuesDateCreate = DateTime.Now;
q.QuesNew = true;
e.UserQuestions.Add(q);
if (e.SaveChanges() > 0)
{
return(true);
}
return(false);
}
public IActionResult Add([FromBody] UserQuestion question)
{
if (ModelState.IsValid)
{
this.unitOfWork.UserQuestion.Add(question);
this.emailService.SendEmail(question.Email, "Обратная связь", "Спасибо за ваш вопрос. С вами обязательно свяжутся наши администраторы!!");
}
else
{
return(StatusCode(400));
}
return(Ok());
}
// GET: UserQuestions/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserQuestion userQuestion = db.UserQuestion.Find(id);
if (userQuestion == null)
{
return(HttpNotFound());
}
return(View(userQuestion));
}
protected void QuestionTypeRadioButtonList_SelectedIndexChanged(object sender, System.EventArgs e)
{
UserQuestion question = (UserQuestion)ViewState["Question"];
question.Values.Clear();
if (QuestionTypeRadioButtonList.SelectedIndex == (int)UserQuestionType.FreeAnswer)
{
MultipleChoicePanel.Visible = false;
}
else if (QuestionTypeRadioButtonList.SelectedIndex == (int)UserQuestionType.MultipleChoice)
{
MultipleChoicePanel.Visible = true;
}
ViewState["Question"] = question;
}
public static int AddUserQuestion(UserQuestion model)
{
using (var entity = new BusEntities())
{
var id = 0;
try
{
entity.AddToUserQuestion(model);
entity.SaveChanges();
id = model.ID;
}
catch { }
return(id);
}
}
// GET: UserQuestions/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserQuestion userQuestion = db.UserQuestion.Find(id);
if (userQuestion == null)
{
return(HttpNotFound());
}
ViewBag.SurveyId = new SelectList(db.Surveys, "SurveyId", "SurveyName", userQuestion.SurveyId);
return(View(userQuestion));
}
private bool PassedQuestion(QuestionViewModel question, ref TempResult tempResult)
{
int IdResult = tempResult.IdResult;
question.IdQuestion = (int)HttpContext.Current.Application["Test" + HttpContext.Current.User.Identity.Name];
UserQuestion userQuestion = Database.UserQuestions.Find(x => x.IdResult == IdResult &&
x.IdQuestion == question.IdQuestion).
SingleOrDefault();
double questionScore = 0;
try
{
Question questionDB = Database.Questions.Get(question.IdQuestion);
double answerWeight = (questionDB.Score / questionDB.Answers.
Where(x => x.Correct == true).
Count());
foreach (Answer answer in questionDB.Answers)
{
AnswerViewModel answerUser = question.Answers.Where(x => x.IdAnswer == answer.IdAnswer).SingleOrDefault();
userQuestion.UserAnswers.Add(new UserAnswer()
{
IdUserQuestion = userQuestion.IdUserQuestion,
IdAnswer = answer.IdAnswer,
Correct = answerUser.Correct
});
if (answerUser.Correct == answer.Correct && answer.Correct == true)
{
questionScore += answerWeight;
userQuestion.UserScore += answerWeight;
}
}
}
catch (Exception e)
{
return(false);
}
tempResult.TotalScore += questionScore;
tempResult.QuestionPassing = tempResult.QuestionPassing.StringStirrer(question.IdQuestion);
tempResult.QuestionsPassed += question.IdQuestion.ToString() + ",";
Database.UserAnswers.AddRange(userQuestion.UserAnswers);
Database.Complete();
Database.UserQuestions.Update(userQuestion);
Database.TempResults.Update(tempResult);
Database.Complete();
return(true);
}
private static void ProcessProjectFiles(
CurrentOperation operation,
string[] conflictPaths,
DirectoryInfo folder,
Logger logger,
string rootFolder )
{
var merger = new ProjectMerger(
operation,
new UserConflictResolver<ProjectReference>( operation, repositoryRootDirectory: rootFolder ),
new ReferenceConflictResolver( new UserConflictResolver<Reference>( operation, notResolveOptionText: PackageNotInstalledText, repositoryRootDirectory: rootFolder ) ),
new UserConflictResolver<RawItem>( operation, repositoryRootDirectory: rootFolder ),
new UserDuplicateResolver<Reference>( operation, notResolveOptionText: PackageNotInstalledText, repositoryRootDirectory: rootFolder ) );
foreach ( var conflict in conflictPaths.Where( p => p.EndsWith( ".csproj" ) || p.EndsWith( ".fsproj" ) || p.EndsWith( ".xproj" )) ) {
var fullConflictPath = Path.Combine( folder.FullName, conflict );
logger.Info( $"{LogHelper.Header}{Environment.NewLine}Examining concurrent modification for {fullConflictPath}" );
var baseContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ancestor, conflict );
var localContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ours, conflict );
var incomingContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Theirs, conflict );
var conflictFolder = Path.GetDirectoryName( Path.Combine( rootFolder, conflict ) );
if ( conflictFolder == null ) {
throw new Exception( "No conflict folder" );
}
if ( string.IsNullOrEmpty( localContent ) || string.IsNullOrEmpty( incomingContent ) ) {
logger.Log( LogLevel.Info, $"Skipping '{conflict}' - no content on one side" );
continue;
}
var localDocument = XDocument.Parse( localContent );
var incomingDocument = XDocument.Parse( incomingContent );
var baseDocument = XDocument.Parse( baseContent ?? "<?xml version=\"1.0\" encoding=\"utf - 8\"?><Project/>" );
var resolved = false;
try {
var projectFolder = Path.Combine( folder.FullName, conflictFolder );
var packagesConfigFilePath = ProjectPackages.GetPackagesConfigFilePath( projectFolder );
var packagesConfig = ProjectPackages.TryLoadPackagesConfig( packagesConfigFilePath );
if ( packagesConfig == null ) {
continue;
}
var packageIndex = new ProjectPackages( projectFolder, NuGetExtensions.FindRelativePathOfPackagesFolder( projectFolder ), packagesConfig );
Item[] items = merger.Merge(
conflict,
packageIndex,
baseDocument,
localDocument,
incomingDocument ).ToArray();
// Now remove everything we have handled, to check if we are done.
ProjectFile.DeleteItems( localDocument );
ProjectFile.DeleteItems( incomingDocument );
ProjectFile.DeleteItems( baseDocument );
ProjectFile.AddItems( baseDocument, items );
ProjectFile.AddItems( localDocument, items );
ProjectFile.AddItems( incomingDocument, items );
XDocument resolvedDocument = null;
var localXml = localDocument.ToString();
var incomingXml = incomingDocument.ToString();
var baseXml = baseDocument.ToString();
// Check for any project file changes outside of the references and items.
if ( localXml == incomingXml ) {
resolvedDocument = localDocument;
} else if ( baseXml == localXml ) {
resolvedDocument = incomingDocument;
} else if ( baseXml == incomingXml ) {
resolvedDocument = localDocument;
}
if ( resolvedDocument != null ) {
// We handled all the differences
using ( var textWriter = new StreamWriter( fullConflictPath ) ) {
SerialisationHelper.WriteXml( resolvedDocument, textWriter );
}
using ( var repository = new Repository( rootFolder ) ) {
repository.Stage( conflict );
}
resolved = true;
}
} catch ( MergeAbortException ) {
logger.Log( LogLevel.Info, $"Project merge aborted for {conflict}" );
continue;
} catch ( UserQuitException ) {
throw;
} catch ( Exception exception ) {
logger.Log( LogLevel.Error, exception, $"Project merge failed for {conflict}{Environment.NewLine}{exception}" );
}
if ( resolved ) {
continue;
}
string userQuestionText = $"Could not resolve conflict: {conflict}{Environment.NewLine}Would you like to resolve the conflict with the mergetool?";
var userQuestion = new UserQuestion<bool>( userQuestionText, UserQuestion<bool>.YesNoOptions() );
if ( userQuestion.Resolve() ) {
using ( var repository = new Repository( rootFolder ) ) {
GitHelper.ResolveWithStandardMergetool(
repository,
fullConflictPath,
baseDocument,
localDocument,
incomingDocument,
logger,
conflict );
}
}
}
}
private static void ProcessPackagesConfig(
CurrentOperation operation,
string[] conflictPaths,
DirectoryInfo folder,
Logger logger,
string rootFolder )
{
var packagesConfigMerger = new PackagesConfigMerger(
operation,
new UserConflictResolver<ConfigitPackageReference>( operation, repositoryRootDirectory: rootFolder ) );
foreach ( var conflict in conflictPaths.Where( p => Path.GetFileName( p ) == "packages.config" ) ) {
var fullConflictPath = Path.Combine( folder.FullName, conflict );
logger.Info( $"{LogHelper.Header}{Environment.NewLine}Examining concurrent modification for {fullConflictPath}" );
var baseContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ancestor, conflict );
var localContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ours, conflict );
var incomingContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Theirs, conflict );
// TODO: Is this correct? if base is not null then we have a deletion of the packages config file
if ( string.IsNullOrEmpty( localContent ) || string.IsNullOrEmpty( incomingContent ) ) {
logger.Log( LogLevel.Info, $"Skipping '{conflict}' - no content on one side" );
continue;
}
bool resolved = false;
try {
var result = packagesConfigMerger.Merge( conflict,
baseContent == null ? new ConfigitPackageReference[0]:
NuGetExtensions.ReadPackageReferences( baseContent ),
NuGetExtensions.ReadPackageReferences( localContent ),
NuGetExtensions.ReadPackageReferences( incomingContent ) ).ToArray();
result.Write( fullConflictPath );
using ( var repository = new Repository( rootFolder ) ) {
repository.Stage( conflict );
resolved = true;
}
} catch ( MergeAbortException ) {
logger.Log( LogLevel.Info, $"Package merge aborted for {conflict}" );
continue;
}
catch ( UserQuitException ) {
throw;
} catch ( Exception exception ) {
logger.Log( LogLevel.Error, exception, $"Package merge failed for {conflict}{Environment.NewLine}{exception}" );
}
if ( resolved ) {
continue;
}
string userQuestionText = $"Could not resolve conflict: {conflict}{Environment.NewLine}Would you like to resolve the conflict with the mergetool?";
var userQuestion = new UserQuestion<bool>( userQuestionText, UserQuestion<bool>.YesNoOptions() );
if ( !userQuestion.Resolve() ) {
continue;
}
XDocument localDocument = XDocument.Parse( localContent );
XDocument theirDocument = XDocument.Parse( incomingContent );
XDocument baseDocument = baseContent == null ? new XDocument() : XDocument.Parse( baseContent );
using ( var repository = new Repository( rootFolder ) ) {
GitHelper.ResolveWithStandardMergetool(
repository,
fullConflictPath,
baseDocument,
localDocument,
theirDocument,
logger,
conflict );
}
}
}
