public IActionResult Post(CreateRecordModel model)
{
if (model.Data.IsEmpty())
{
return(JError("data is empty"));
}
Schema.Domain.Entity entityMeta = null;
if (model.EntityId.HasValue && !model.EntityId.Value.Equals(Guid.Empty))
{
entityMeta = _entityFinder.FindById(model.EntityId.Value);
}
else if (model.EntityName.IsNotEmpty())
{
entityMeta = _entityFinder.FindByName(model.EntityName);
}
if (entityMeta == null)
{
return(NotFound());
}
var childAttributes = _attributeFinder.FindByEntityName(entityMeta.Name);
if (model.Data.StartsWith("["))
{
var details = new List <Entity>();
var items = JArray.Parse(model.Data.UrlDecode());
if (items.Count > 0)
{
foreach (var c in items)
{
dynamic root = JObject.Parse(c.ToString());
Entity detail = new Entity(entityMeta.Name);
foreach (JProperty p in root)
{
var attr = childAttributes.Find(n => n.Name.IsCaseInsensitiveEqual(p.Name));
if (attr != null && p.Value != null)
{
detail.SetAttributeValue(p.Name.ToString().ToLower(), detail.WrapAttributeValue(_entityFinder, attr, p.Value.ToString()));
}
}
details.Add(detail);
}
}
return(_dataCreater.CreateMany(details).CreateResult(T));
}
else
{
dynamic root = JObject.Parse(model.Data.UrlDecode());
Entity detail = new Entity(entityMeta.Name);
foreach (JProperty p in root)
{
var attr = childAttributes.Find(n => n.Name.IsCaseInsensitiveEqual(p.Name));
if (attr != null)
{
detail.SetAttributeValue(p.Name.ToString().ToLower(), detail.WrapAttributeValue(_entityFinder, attr, p.Value.ToString()));
}
}
var id = _dataCreater.Create(detail);
return(CreateSuccess(new { id = id }));
}
}
public async Task <int> CreateAsync(CreateRecordModel createRecordModel, string userId)
{
var account = await _accountRepository.GetByIdAsync(createRecordModel.AccountId);
if (account == null)
{
throw new BudgetValidationException(
string.Format(ValidationMessages.Common.EntityDoesNotExist, nameof(account), createRecordModel.AccountId));
}
if (account.UserId != userId)
{
throw new BudgetValidationException(
string.Format(ValidationMessages.Accounts.InvalidAccount, account.Name));
}
var record = new Record()
{
AccountId = account.Id,
Amount = createRecordModel.Amount,
DateAdded = _dateTimeProvider.Now,
Note = createRecordModel.Note,
CategoryId = createRecordModel.CategoryId,
PaymentTypeId = createRecordModel.PaymentTypeId,
RecordType = createRecordModel.RecordType,
};
var createdRecord = await _recordRepository.CreateAsync(record);
return(createdRecord.Id);
}
public IActionResult CreateRecord(CreateRecordModel model)
{
var board = _boards.GetEntity(model.BoardId);
if (board == null)
{
return(RedirectToAction("Boards"));
}
if (ModelState.IsValid)
{
var column = board.Columns.FirstOrDefault(col => col.Id == model.ColumnId);
var record = new Record
{
Column = column,
Value = model.Value.Trim()
};
_records.AddEntity(record);
_records.Save();
}
else
{
ModelState.AddModelError("Name", "Missing name!");
}
return(RedirectToAction("Board", new { id = board.Id }));
}
public async Task <IActionResult> Post([FromBody] CreateRecordModel model)
{
var result = await recordService.Create(UserId, model);
if (result.Succeeded)
{
return(Ok(result.Response));
}
return(BadRequest(result.Error));
}
public async Task CreateNotEnoughMoney()
{
var amount = 11000;
var description = "Create";
var isIncome = false;
var model = new CreateRecordModel
{
Amount = amount,
Description = description,
IsIncome = isIncome,
CategoryId = categoryId
};
var result = await recordService.Create(userId, model);
Assert.IsFalse(result.Succeeded);
Assert.AreEqual("Not enough money", result.Error.Message);
}
public async Task CreateWrongCategoryId()
{
var amount = 9000;
var description = "Create";
var isIncome = false;
var model = new CreateRecordModel
{
Amount = amount,
Description = description,
IsIncome = isIncome,
CategoryId = wrongCategoryId
};
var result = await recordService.Create(userId, model);
Assert.IsFalse(result.Succeeded);
Assert.AreEqual("Category not Found", result.Error.Message);
}
public async Task <ServiceResponse <RecordModel> > Create(string userId, CreateRecordModel model)
{
var category = await context.Categories.FindAsync(model.CategoryId);
if (category == null)
{
return(Error("Category not Found"));
}
if (category.UserId != userId)
{
return(Error("Access Forbidden"));
}
var user = await context.Users.FindAsync(userId);
if (user == null)
{
return(Error("User not Found"));
}
if (model.IsIncome)
{
user.Bill += model.Amount;
}
else
{
user.Bill -= model.Amount;
}
if (user.Bill < 0)
{
return(Error("Not enough money"));
}
var record = mapper.Map <CreateRecordModel, Record>(model);
record.UserId = userId;
try
{
await context.Records.AddAsync(record);
await context.SaveChangesAsync();
}
catch
{
return(Error("Creation Failed"));
}
return(Success(mapper.Map <Record, RecordModel>(record)));
}
public async Task Create()
{
var amount = 9000;
var description = "Create";
var isIncome = false;
var model = new CreateRecordModel
{
Amount = amount,
Description = description,
IsIncome = isIncome,
CategoryId = categoryId
};
var result = await recordService.Create(userId, model);
Assert.AreEqual(amount, result.Response.Amount);
Assert.AreEqual(description, result.Response.Description);
Assert.AreEqual(isIncome, result.Response.IsIncome);
}
public async Task <IActionResult> Post([FromBody] CreateRecordModel model)
{
try
{
//check that user is in team
var user = await _userService.GetCurrentUserAsync(TenantId);
if (user == null)
{
return(Unauthorized());
}
//check that user has access to form
var form = await _tenantRepository.GetFormForUserByFormId(user.Id, model.FormId, TenantId);
if (form == null)
{
return(Unauthorized());
}
var record = new Record
{
FormId = model.FormId,
RecordJson = JsonConvert.SerializeObject(model.ResponseJson),
Status = RecordStatus.Submitted,
Location = new Location
{
Latitude = model.Latitude,
Longitude = model.Longitude,
},
UserId = user.Id,
Message = "Submitted",
LocalTitle = model.LocalTitle
};
await _tenantRepository.AddRecord(record, TenantId);
return(Ok());
}
catch (Exception e)
{
return(BadRequest());
}
}
public async Task <IActionResult> CreateRecord(CreateRecordModel model)
{
CustomValidation();
var userId = User.GetSubjectId();
var user = await _databaseContext.UserData.FirstOrDefaultAsync(UserIdPredicate(userId));
if (user == null)
{
throw new HttpResponseException(null, HttpStatusCode.Unauthorized);
}
var storedCollection = await
_databaseContext.Collection.FirstOrDefaultAsync(c =>
c.Id == model.CollectionId && c.OwnerId == user.Id);
var storedRecordType =
await _databaseContext.RecordType
.FirstOrDefaultAsync(rt => rt.Id == model.RecordTypeId);
var storedRecordFormat = await _databaseContext.RecordFormat.FirstOrDefaultAsync(
rt => rt.Id == model.RecordFormatId);
var storedImage =
await _databaseContext.Image
.FirstOrDefaultAsync(i => i.Id == model.ImageId && i.CreatorId == user.Id);
var storedStyles = _databaseContext.Style.Where(s => model.StyleIds.Contains(s.Id));
if (storedCollection == null || storedRecordType == null || storedStyles == null ||
storedRecordFormat == null)
{
throw new HttpResponseException(null, HttpStatusCode.BadRequest);
}
var newRecord = new Record
{
Name = model.Name,
Artist = model.Artist,
Description = model.Description,
CollectionId = storedCollection.Id,
OwnerId = user.Id,
CreationDate = DateTime.UtcNow,
ImageId = storedImage?.Id,
RecordTypeId = storedRecordType.Id,
RecordFormatId = storedRecordFormat.Id,
Label = model.Label,
Year = model.Year,
RecordLength = model.RecordLength,
};
await _databaseContext.Record.AddAsync(newRecord);
var newRecordStyles = storedStyles.Select(s => new RecordStyle
{
Record = newRecord,
StyleId = s.Id
});
await _databaseContext.RecordStyle.AddRangeAsync(newRecordStyles);
await _databaseContext.SaveChangesAsync();
await _userActivityService.CreateActivityAsync(UserActivityActionName.RecordCreate, user.Id,
record : newRecord);
return(Created("/api/record", newRecord));
}
public async Task <IActionResult> Create(CreateRecordModel createRecordModel) => Ok(await _recordService.CreateAsync(createRecordModel, LoggedInUserId));
