private void Done(object sender, EventArgs e)
{
if (IsFieldsEmpty())
{
this.ShowMessage(Resource.String.please_fill_all_fields);
return;
}
var outcomeModel = new OutcomeModel()
{
Title = edtTitle.Text,
Amount = long.Parse(edtAmount.Text),
Group = outcomeGroup.Id,
Date = deadLine,
Items = items
};
var progressDialog = this.CreateDialog(GetString(Resource.String.adding_outcome),
GetString(Resource.String.wait));
progressDialog.Show();
this.DoRequest(OutComesController.Instance.Add(outcomeModel), () =>
{
progressDialog.Dismiss();
this.ShowMessage(Resource.String.create_outcome_success);
SetResult(Result.Ok);
Finish();
});
}
public ResponseResultModel Get(string username, string pwd)
{
Log.Information("CreateUser : "******"User logged";
response.outcome = outcome;
response.result = u;
}
else
{
outcome.isSuccess = false;
outcome.description = "Unauthorized user.";
response.outcome = outcome;
}
}
return(response);
}
public virtual ActionResult ReassignIndicator(CustomReassignOutcomeIndicatorModel reassignModel)
{
int code = 0;
try
{
OutcomeIndicatorModel indicatorModel = ClientResultsMatrix.FindOneOutcomeIndicatorModel(
new OutcomeIndicatorSpecification {
OutcomeIndicatorId = reassignModel.OutcomeIndicatorId
});
indicatorModel.AccessedByAdministrator = IDBContext.Current.HasRole(Role.RM_ADMINISTRATOR);
indicatorModel.IsThirdInterval = reassignModel.IsThirdInterval;
indicatorModel.IntervalId = reassignModel.IntervalId;
OutcomeModel currentImpactModel = ClientResultsMatrix.FindOneOutcomeModel(
new OutcomeSpecification {
OutcomeId = indicatorModel.OutcomeId
});
OutcomeModel newImpactModel = ClientResultsMatrix.FindOneOutcomeModel(
new OutcomeSpecification {
OutcomeId = reassignModel.ImpactId
});
if (indicatorModel != null & currentImpactModel != null && newImpactModel != null)
{
ClientResultsMatrix.ReassignIndicator(
currentImpactModel,
newImpactModel,
indicatorModel,
IDBContext.Current.UserName);
code = 503;
}
}
catch (Exception)
{
code = 497;
}
_cacheData.Remove(_outcomeIndicatorCacheName, System.Web.Caching.CacheItemRemovedReason.Removed);
_cacheData.Remove(_outcomesCacheName, System.Web.Caching.CacheItemRemovedReason.DependencyChanged);
var resultsMatrix = ClientResultsMatrix.FindOneModel(
new ResultsMatrixSpecification {
ResultsMatrixId = reassignModel.ResultsMatrixId
});
return(RedirectToAction(
"Edit",
"Outcomes",
new
{
operationId = resultsMatrix.OperationId,
resultsMatrixId = resultsMatrix.ResultsMatrixId,
code = code
}));
}
public virtual ActionResult Delete(
int impactId, int intervalId, bool accessedByAdmin, bool isThirInterval)
{
string user = IDBContext.Current.UserLoginName;
Logger.GetLogger().WriteMessage(
"OutcomesController", string.Format("I am {0}, accessAdmin: {1}", user, accessedByAdmin));
CustomDeleteOutcomeModel deleteImpactModel = new CustomDeleteOutcomeModel();
int totalRows = 0;
OutcomeModel currentImpact = _clientResultsMatrix.FindOneOutcomeModel(
new OutcomeSpecification()
{
OutcomeId = impactId
});
var existingImpacts = _clientResultsMatrix.FindAllOutcomeModelsBySpecification(
totalRows,
new OutcomeSpecification()
{
ResultsMatrixId = currentImpact.ResultsMatrixId
},
int.MaxValue,
0,
null).ToList <OutcomeModel>();
existingImpacts.Where(x => x.OutcomeId == currentImpact.OutcomeId).ForEach(x =>
x.Statement = "Delete");
existingImpacts.Sort((x, y) => x.Statement.CompareTo(y.Statement));
deleteImpactModel.currentImpact = currentImpact;
deleteImpactModel.existingImpacts = existingImpacts.ToList <OutcomeModel>();
deleteImpactModel.intervalId = intervalId;
deleteImpactModel.resultsMatrixId = currentImpact.ResultsMatrixId;
if (intervalId == ResultsMatrixCodes.ThirdInterval || (accessedByAdmin && isThirInterval))
{
deleteImpactModel.AccessedByAdministrator = accessedByAdmin;
deleteImpactModel.IsThirdInterval = isThirInterval;
ViewData["message"] = Localization.GetText("TCM.RCMW.RegisterChangesMany.TextMessage");
}
else
{
deleteImpactModel.AccessedByAdministrator = accessedByAdmin;
deleteImpactModel.IsThirdInterval = false;
}
deleteImpactModel.IsValidated =
ClientResultsMatrix.IsValidateOutcomeBYOutcomeIndicatorYearPlans(impactId);
return(PartialView(deleteImpactModel));
}
public async Task <Outcome> SaveOutcomeAsync(OutcomeModel outcomeModel)
{
//using (var transaction = await _db.Database.BeginTransactionAsync())
//{
Outcome outcome;
if (outcomeModel.Id.HasValue)
{
outcome = await _db.Outcomes
.Include(o => o.Photo)
.FirstAsync(o => o.Id == outcomeModel.Id.Value);
}
else
{
outcome = new Outcome();
_db.Add(outcome);
}
outcome.Name = outcomeModel.Name;
outcome.Summary = outcomeModel.Summary;
outcome.PhotoId = outcomeModel.PhotoId;
outcome.QuizId = outcomeModel.QuizId;
var existingRoleOutcomes = _db.CharacterRoleOutcomes.Where(cro => cro.OutcomeId == outcome.Id);
_db.RemoveRange(existingRoleOutcomes);
await _db.SaveChangesAsync();
foreach (var roleOutcomeModel in outcomeModel.CharacterRoleOutcomes)
{
outcome.CharacterRoleOutcomes.Add(new CharacterRoleOutcome {
CharacterRoleId = roleOutcomeModel.CharacterRoleId,
OutcomeId = outcome.Id,
Value = roleOutcomeModel.Value
});
}
await _db.SaveChangesAsync();
//transaction.Commit();
return(await _db.Outcomes
.Include(o => o.CharacterRoleOutcomes)
.ThenInclude(o => o.CharacterRole)
.Include(o => o.AnswerOutcomes)
.ThenInclude(o => o.Answer)
.ThenInclude(o => o.Question)
.FirstAsync(o => o.Id == outcome.Id));
//}
}
public ActionResult Outcomes(string lmsProviderName)
{
if (string.IsNullOrEmpty(lmsProviderName))
{
this.ViewBag.Message = "Required parameters were not provided. Please refresh page and try again.";
return(this.View("~/Views/Lti/LtiError.cshtml"));
}
var model = new OutcomeModel
{
LmsProviderName = lmsProviderName
};
return(View("~/Views/Lti/Outcomes.cshtml", model));
}
private void Init()
{
var content = Intent.GetStringExtra("OutcomeDetail");
outcomeModel = JsonConvert.DeserializeObject <OutcomeModel>(content);
outcomeGroup = AppConstantValues.FeeGrooups.Find(x => x.Id.Equals(outcomeModel.Group));
deadLine = outcomeModel.Date;
tvTitle.Text = GetString(Resource.String.edit_outcome);
edtTitle.Text = outcomeModel.Title;
edtAmount.Text = outcomeModel.Amount.ToString();
edtChooseOutcomeGroup.Text = GetString(outcomeGroup.TitleId);
imgViewChooseOutcomeGroup.SetImageResource(outcomeGroup.ImageId);
edtDeadline.Text = deadLine.ToDateString();
}
public OutcomeEntity(OutcomeModel model)
{
Id = model.Key.AsGuidKey().Guid;
Description = model.Description;
Amount = model.Amount.Value;
Currency = model.Amount.Currency;
When = model.When;
Categories = new List <OutcomeCategoryEntity>();
foreach (IKey categoryKey in model.CategoryKeys)
{
Categories.Add(new OutcomeCategoryEntity()
{
OutcomeId = Id,
CategoryId = categoryKey.AsGuidKey().Guid
});
}
}
public virtual ActionResult Reassign(int resultsMatrixId, int impactId, int impactIndicatorId)
{
// Check if the administrator is accessing
var accessedByAdministrator = IDBContext.Current.HasRole(Role.RM_ADMINISTRATOR);
// Get results matrix with interval data associated to administrator
var lightResultModel = ClientResultsMatrix.GetLightResultsMatrixModel(new ResultsMatrixModel()
{
ResultsMatrixId = resultsMatrixId, AccessedByAdministrator = accessedByAdministrator
});
// Set impact data
OutcomeModel currentImpact = ClientResultsMatrix.FindOneOutcomeModel(new OutcomeSpecification()
{
OutcomeId = impactId
});
// Get outcomes
IDB.MW.Domain.Models.Architecture.ResultMatrix.Outcomes.ResultsMatrixModel resultModel = ClientResultsMatrix.FindOneModel(new ResultsMatrixSpecification()
{
ResultsMatrixId = resultsMatrixId
});
List <OutcomeModel> outcomes = resultModel.Outcomes;
// Remove current outcome
outcomes.RemoveAll(i => i.OutcomeId == impactId);
// Set reassign model properties
CustomReassignOutcomeIndicatorModel reassignModel = new CustomReassignOutcomeIndicatorModel()
{
Statement = currentImpact.Statement,
Definition = currentImpact.OutcomeIndicators.Where(ii => ii.OutcomeIndicatorId == impactIndicatorId).SingleOrDefault <OutcomeIndicatorModel>().Definition,
OutcomeIndicatorId = impactIndicatorId,
ResultsMatrixId = lightResultModel.ResultsMatrixId,
AccessedByAdministrator = accessedByAdministrator,
IsThirdInterval = lightResultModel.IsThirdInterval,
ImpactId = impactId,
Outcomes = outcomes,
IntervalId = lightResultModel.Interval.IntervalId
};
return(PartialView(reassignModel));
}
public virtual ActionResult EditDetail(int impactIndicatorId)
{
OutcomeIndicatorModel indicatorModel = ClientResultsMatrix.FindOneOutcomeIndicatorModel(new OutcomeIndicatorSpecification()
{
OutcomeIndicatorId = impactIndicatorId
});
OutcomeModel impactModel = ClientResultsMatrix.FindOneOutcomeModel(new OutcomeSpecification()
{
OutcomeId = indicatorModel.OutcomeId
});
bool isLinked = (indicatorModel.PredefinedIndicator == null) ? false : true;
// Start third interval validation
var operationNumber = ClientResultsMatrix.FindOneModel(new ResultsMatrixSpecification()
{
ResultsMatrixId = impactModel.ResultsMatrixId
}).Operation.OperationNumber;
// Check if the administrator is accessing
var accessedByAdministrator = IDBContext.Current.HasRole(Role.RM_ADMINISTRATOR);
var resultsMatrix = ClientResultsMatrix.GetResultsMatrixModel(new OperationModel()
{
OperationNumber = operationNumber, AccessedByAdministrator = accessedByAdministrator
});
// End third interval validation
CustomEditOutcomeIndicatorModel editImpactIndicatoModel = new CustomEditOutcomeIndicatorModel
{
impact = impactModel,
impactIndicator = indicatorModel,
IsLinkedToPredefinedIndicator = isLinked,
IntervalId = resultsMatrix.Interval.IntervalId,
AccessedByAdministrator = accessedByAdministrator,
IsThirdInterval = resultsMatrix.IsThirdInterval,
OperationNumber = operationNumber,
IsTcmModule = false
};
return(View(editImpactIndicatoModel));
}
private void OnClickSave(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(edtAmount.Text) &&
DateTime.TryParse(edtDate.Text, out var date) &&
!string.IsNullOrEmpty(edtTitle.Text) &&
!string.IsNullOrEmpty(edtDescription.Text))
{
if (int.TryParse(edtAmount.Text, out var amount) && amount > 0)
{
var outcomeModel = new OutcomeModel()
{
Title = edtTitle.Text,
Amount = amount,
Date = date
};
try
{
OutComesController.Instance.Add(outcomeModel);
SaveClick?.Invoke(outcomeModel, e);
Dismiss();
}
catch (Exception ex)
{
this.ShowMessage(ex.Message);
}
}
else
{
this.ShowMessage(Resource.String.amount_parse_error_message);
}
edtDescription.Text = string.Empty;
edtAmount.Text = string.Empty;
edtDate.Text = string.Empty;
edtTitle.Text = string.Empty;
}
else
{
this.ShowMessage(Resource.String.add_outcome_dialog_error);
}
}
public virtual ActionResult Detail(int resultsMatrixId, int impactId, int impactIndicatorId)
{
OutcomeModel impactModel = ClientResultsMatrix.FindOneOutcomeModel(new OutcomeSpecification()
{
OutcomeId = impactId
});
var impactIndicatorModel = impactModel.OutcomeIndicators.Where(ii => ii.OutcomeIndicatorId == impactIndicatorId).SingleOrDefault <OutcomeIndicatorModel>();
var resultModel = ClientResultsMatrix.FindOneModel(new ResultsMatrixSpecification()
{
ResultsMatrixId = resultsMatrixId
});
impactModel.OutcomeIndicators.Clear();
impactModel.OutcomeIndicators.Add(impactIndicatorModel);
ViewData["operationNumber"] = resultModel.Operation.OperationNumber;
var StateDraftId = ClientConvergenceMasterData.GetMasterDataId("VALIDATION_STAGE", "PMI_DRAFT");
var isDraft = false;
if (resultModel.ValidationStageId == StateDraftId)
{
isDraft = true;
}
ViewBag.isDraft = isDraft;
ViewBag.isEditable = ClientResultsMatrix.GetLightResultsMatrixModel(new ResultsMatrixModel()
{
ResultsMatrixId = resultModel.ResultsMatrixId
}).isEditable;
return(View(impactModel));
}
public ActionResult Outcomes(OutcomeModel model, string submit)
{
if (string.IsNullOrEmpty(model.LmsProviderName))
{
this.ViewBag.Message = "Session parameter is required. Please refresh page and try again.";
return(this.View("~/Views/Lti/LtiError.cshtml"));
}
var session = GetReadOnlySession(model.LmsProviderName);
var lmsLicense = session.LmsCompany;
var outcomeUrl = session.LtiSession.LtiParam.lis_outcome_service_url;
var outcomeSourceId = session.LtiSession.LtiParam.lis_result_sourcedid;
if (string.IsNullOrWhiteSpace(outcomeUrl) || string.IsNullOrWhiteSpace(outcomeSourceId))
{
this.ViewBag.Message = "Outcomes service is unavailable for current session. Please refresh page and try again.";
return(this.View("~/Views/Lti/LtiError.cshtml"));
}
switch (submit)
{
case "Send Grade":
if (LtiOutcomesHelper.PostScore(outcomeUrl, lmsLicense.ConsumerKey, lmsLicense.SharedSecret,
outcomeSourceId, model.Score))
{
ViewBag.Message = "Grade sent";
}
else
{
ViewBag.Message = "Invalid request";
}
break;
case "Read Grade":
var lisResult = LtiOutcomesHelper.ReadScore(outcomeUrl, lmsLicense.ConsumerKey,
lmsLicense.SharedSecret, outcomeSourceId);
if (lisResult.IsValid)
{
model.Score = lisResult.Score;
ViewBag.Message = "Grade read";
}
else
{
ViewBag.Message = "No grade";
}
break;
case "Delete Grade":
if (LtiOutcomesHelper.DeleteScore(outcomeUrl, lmsLicense.ConsumerKey, lmsLicense.SharedSecret,
outcomeSourceId))
{
model.Score = null;
ViewBag.Message = "Grade deleted";
}
else
{
ViewBag.Message = "Invalid request";
}
break;
}
return(View("~/Views/Lti/Outcomes.cshtml", model));
}
public async Task <OutcomeModel> SaveOutcome(OutcomeModel outcomeModel)
{
var outcome = await _outcomeService.SaveOutcomeAsync(outcomeModel);
return(_mapper.Map <OutcomeModel>(outcome));
}
