public async Task <IActionResult> CreateRecord([FromBody] Record model)
{
var currentUserId = int.Parse(User.Identity.Name);
try
{
var exercise = await _exerciseTypeService.FindAsync(model.ExerciseTypeId);
var record = await _recordService.Create(model, exercise, currentUserId);
return(Ok(record));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public IHttpActionResult Post([FromBody] CreateRecordViewModel model)
{
if (model == null)
{
return(BadRequest());
}
Record record = new Record
{
Name = model.Name,
CreateDate = model.CreateDate,
Description = model.Description,
CategoryId = model.CategoryId,
PictureId = model.PictureId
};
recordService.Create(record);
return(Ok());
}
public object CreateNewFieldValue(string fieldName, string recordType, IRecordService recordService,
IRecord currentRecord)
{
var currentValueNull = currentRecord.GetField(fieldName) == null;
var fieldType = recordService.GetFieldType(fieldName, recordType);
switch (fieldType)
{
case (RecordFieldType.String):
{
return(currentValueNull ? "BLAH" : "BLAHBLAH");
}
case (RecordFieldType.Date):
{
return(currentValueNull ? new DateTime(1980, 11, 15) : new DateTime(2001, 1, 1));
}
case (RecordFieldType.Lookup):
{
var lookupTargetType = recordService.GetLookupTargetType(fieldName, recordType);
IRecord referenceRecord = null;
if (currentValueNull)
{
referenceRecord = recordService.GetFirst(lookupTargetType);
}
else
{
var rs = recordService.GetFirstX(lookupTargetType, 2, null, null, null);
if (rs.Any(r => r.Id != currentRecord.GetLookupId(fieldName)))
{
referenceRecord = rs.First(r => r.Id != currentRecord.GetLookupId(fieldName));
}
}
if (referenceRecord == null)
{
referenceRecord = recordService.NewRecord(lookupTargetType);
referenceRecord.SetField(recordService.GetPrimaryField(lookupTargetType), "TestLookup",
recordService);
recordService.Create(referenceRecord);
}
return(referenceRecord.Id);
}
case (RecordFieldType.Picklist):
case (RecordFieldType.Status):
{
var options = recordService.GetPicklistKeyValues(fieldName, recordType);
var option1 = options.First().Key;
var option2 = options.Count() > 1 ? options.ElementAt(1).Key : options.First().Key;
if (currentValueNull)
{
return(option1);
}
else
{
return(currentRecord.GetOptionKey(fieldName) == option1 ? option2 : option1);
}
}
case (RecordFieldType.Boolean):
{
return(currentValueNull);
}
case (RecordFieldType.Integer):
{
if (XrmRecordService.GetFieldMetadata(fieldName, recordType).IntegerFormat == IntegerType.TimeZone)
{
var timezoneRecords = XrmRecordService.GetFirstX("timezonedefinition", 2, null, null);
if (timezoneRecords.Count() < 2)
{
throw new Exception("At least 2 Records Required");
}
var option1 = timezoneRecords.ElementAt(0).GetIntegerField("timezonecode");
var option2 = timezoneRecords.ElementAt(1).GetIntegerField("timezonecode");
if (currentValueNull)
{
return(option1);
}
else
{
return(currentRecord.GetIntegerField(fieldName) == option1 ? option2 : option1);
}
}
else
{
return(currentValueNull ? 111 : 222);
}
}
case (RecordFieldType.Decimal):
{
return(currentValueNull ? new Decimal(111) : new decimal(222));
}
case (RecordFieldType.Money):
{
return(currentValueNull ? new Decimal(111) : new decimal(222));
}
case (RecordFieldType.Double):
{
return(currentValueNull ? 111 : 222);
}
case (RecordFieldType.Uniqueidentifier):
{
return(currentValueNull ? Guid.NewGuid().ToString() : currentRecord.Id);
}
default:
{
throw new ArgumentOutOfRangeException("Unmatched field type " + fieldType);
}
}
}
public static string Create(this IRecordService recordService, IRecord record)
{
return(recordService.Create(record, null));
}
public ActionResult <Record> Create([FromBody] Record record)
{
var result = _recordService.Create(record);
return(result);
}
public async Task Create(RecordViewModel recordVM)
{
var record = _mapper.Map <Record>(recordVM);
await _recordService.Create(record);
}
private void InitializeViewModel()
{
_viewModel = new PlanningPageViewModel()
{
SimpleEventsViewModel = new EventListViewModel <SimpleEventViewModel>()
{
AddCommand = new Command(
() => OpenDetails(_simpleEventService.PrepareNew(new SimpleEventViewModel()
{
UserId = GlobalVariables.UserId
}) as SimpleEventViewModel, true)),
EditCommand = new DataGridSelectedItemCommand <SimpleEventViewModel>(GridSimpleEvents,
(item) => OpenDetails(item), null, true),
DeleteCommand = new DataGridSelectedItemsCommand <SimpleEventViewModel>(GridSimpleEvents,
(items) => Delete(_simpleEventService, items, _viewModel.SimpleEventsViewModel)),
ApplyNowCommand = new DataGridSelectedItemsCommand <SimpleEventViewModel>(GridSimpleEvents,
(items) =>
{
foreach (var item in items)
{
_recordService.Add(_recordService.Create(item));
}
NotifyDataChanged();
}),
CreateTransactionCommand = new DataGridSelectedItemCommand <SimpleEventViewModel>(GridSimpleEvents,
(item) => OpenDetails(_recordService.Create(item), true)),
RunCommand = ChangeStateCommand(_simpleEventService, EventState.Active, GridSimpleEvents),
PauseCommand = ChangeStateCommand(_simpleEventService, EventState.Paused, GridSimpleEvents),
CloseCommand = ChangeStateCommand(_simpleEventService, EventState.Closed, GridSimpleEvents)
},
MoneyTransferEventsViewModel = new EventListViewModel <MoneyTransferEventViewModel>()
{
AddCommand = new Command(
() => OpenDetails(_moneyTransferEventService.PrepareNew(new MoneyTransferEventViewModel()
{
UserId = GlobalVariables.UserId
}) as MoneyTransferEventViewModel, true)),
EditCommand = new DataGridSelectedItemCommand <MoneyTransferEventViewModel>(GridMoneyTransferEvents,
(item) => OpenDetails(item), null, true),
DeleteCommand = new DataGridSelectedItemsCommand <MoneyTransferEventViewModel>(GridMoneyTransferEvents,
(items) => Delete(_moneyTransferEventService, items, _viewModel.MoneyTransferEventsViewModel)),
ApplyNowCommand = new DataGridSelectedItemsCommand <MoneyTransferEventViewModel>(GridMoneyTransferEvents,
(items) =>
{
foreach (var item in items)
{
_moneyTransferService.Add(_moneyTransferService.Create(item));
}
NotifyDataChanged();
}),
CreateTransactionCommand = new DataGridSelectedItemCommand <MoneyTransferEventViewModel>(GridMoneyTransferEvents,
(item) => OpenDetails(_moneyTransferService.Create(item), true)),
RunCommand = ChangeStateCommand(_moneyTransferEventService, EventState.Active, GridMoneyTransferEvents),
PauseCommand = ChangeStateCommand(_moneyTransferEventService, EventState.Paused, GridMoneyTransferEvents),
CloseCommand = ChangeStateCommand(_moneyTransferEventService, EventState.Closed, GridMoneyTransferEvents)
},
RepayDebtEventsViewModel = new EventListViewModel <RepayDebtEventViewModel>()
{
AddCommand = new Command(
() => OpenDetails(_repayDebtEventService.PrepareNew(new RepayDebtEventViewModel()
{
UserId = GlobalVariables.UserId
}) as RepayDebtEventViewModel, true)),
EditCommand = new DataGridSelectedItemCommand <RepayDebtEventViewModel>(GridRepayDebtEvents,
(item) => OpenDetails(item), null, true),
DeleteCommand = new DataGridSelectedItemsCommand <RepayDebtEventViewModel>(GridRepayDebtEvents,
(items) => Delete(_repayDebtEventService, items, _viewModel.RepayDebtEventsViewModel)),
ApplyNowCommand = new DataGridSelectedItemsCommand <RepayDebtEventViewModel>(GridRepayDebtEvents,
(items) =>
{
foreach (var item in items)
{
_recordService.Add(_recordService.Create(item));
}
NotifyDataChanged();
}),
CreateTransactionCommand = new DataGridSelectedItemCommand <RepayDebtEventViewModel>(GridRepayDebtEvents,
(item) => OpenDetails(_recordService.Create(item), true)),
RunCommand = ChangeStateCommand(_repayDebtEventService, EventState.Active, GridRepayDebtEvents),
PauseCommand = ChangeStateCommand(_repayDebtEventService, EventState.Paused, GridRepayDebtEvents),
CloseCommand = ChangeStateCommand(_repayDebtEventService, EventState.Closed, GridRepayDebtEvents)
},
LimitsViewModel = new LimitListViewModel <LimitModel>()
{
AddCommand = new Command(
() => OpenDetails(_limitService.PrepareNew(new LimitModel {
UserId = GlobalVariables.UserId
}), true)),
EditCommand = new DataGridSelectedItemCommand <LimitModel>(GridLimits,
(item) => OpenDetails(item), null, true),
DeleteCommand = new DataGridSelectedItemsCommand <LimitModel>(GridLimits,
(items) => Delete <LimitModel, LimitModel>(_limitService, items, _viewModel.LimitsViewModel)),
RemoveClosedCommand = new Command(
() =>
{
_limitService.RemoveClosed(GlobalVariables.UserId);
// remove in grid
foreach (var item in _viewModel.LimitsViewModel.Entities.Where(x => x.State == LimitState.Closed).ToList())
{
_viewModel.LimitsViewModel.Entities.Remove(item);
}
NotifyDataChanged();
})
}
};
SimpleEventsBorder.DataContext = _viewModel.SimpleEventsViewModel;
MoneyTransferEventsBorder.DataContext = _viewModel.MoneyTransferEventsViewModel;
RepayDebtEventsBorder.DataContext = _viewModel.RepayDebtEventsViewModel;
ExpanderLimits.DataContext = _viewModel.LimitsViewModel;
}
