private void ValidateDateRange(AdditionalField addField, AFValue afv)
{
if (addField.Range.Count != 0)
{
DateTime minDate = DateTime.Parse(addField.Range[0].Value);
DateTime maxDate = DateTime.Parse(addField.Range[1].Value);
bool isInRange = true;
foreach (AFValueItem item in afv.Values)
{
if (isInRange)
{
try
{
DateTime afvDate = DateTime.Parse(item.Value);
isInRange = afvDate >= minDate && afvDate <= maxDate;
}
catch (FormatException)
{
isInRange = false;
}
}
else
{
break;
}
}
if (!isInRange)
{
throw new BusinessLogicException($"Error: One Request's additional field value was invalid, check {addField.Name}'s range");
}
}
}
public void GetIsOk()
{
Guid guid = Guid.NewGuid();
AdditionalField additionalField = new AdditionalField()
{
Id = guid,
Name = "Just Testing",
FieldType = "Field Type",
Type = new TypeEntity(),
TypeId = Guid.NewGuid(),
};
AdditionalField dummyAdditionalField = new AdditionalField();
dummyAdditionalField.Id = guid;
var mock = new Mock <IRepository <AdditionalField, TypeEntity> >(MockBehavior.Strict);
mock.Setup(m => m.Exist(dummyAdditionalField)).Returns(true);
mock.Setup(m => m.Get(guid)).Returns(additionalField);
var controller = new AdditionalFieldLogic(mock.Object);
AdditionalField result = controller.Get(guid);
Assert.AreEqual(additionalField, result);
}
private void ValidateTextRange(AdditionalField addField, AFValue afv)
{
if (addField.Range.Count != 0)
{
bool isInRange = true;
bool notFound;
foreach (AFValueItem item in afv.Values)
{
notFound = true;
foreach (AFRangeItem r in addField.Range)
{
if (r.Value == item.Value)
{
notFound = false;
break;
}
}
if (notFound)
{
isInRange = false;
break;
}
}
if (!isInRange)
{
throw new BusinessLogicException("Error: One Request's additional field value was invalid, check fields's range");
}
}
}
private void ValidateAFRange(AdditionalField af)
{
if (af.FieldType == FieldType.Bool && af.Range.Count != 0)
{
throw new BusinessLogicException("Error: A boolean type Additional Field's range can't contain values");
}
if (af.Range.Count != 0)
{
if (af.FieldType == FieldType.Texto)
{
ValidateTextRange(af);
}
else if (af.Range.Count == 2)
{
if (af.FieldType == FieldType.Fecha)
{
ValidateDateRange(af);
}
else
{
ValidateIntegerRange(af);
}
}
else
{
throw new BusinessLogicException($"Error: {af.Name}'s range has too many date or integer values");
}
}
}
public void GetAllIsOk()
{
AdditionalField firstAdditionalFieldExpected = new AdditionalField()
{
Id = Guid.NewGuid(),
Name = "Just Testing",
FieldType = "Field Type",
Type = new TypeEntity(),
TypeId = Guid.NewGuid(),
};
AdditionalField secondAdditionalFieldExpected = new AdditionalField()
{
Id = Guid.NewGuid(),
Name = "Just Testing",
FieldType = "Field Type",
Type = new TypeEntity(),
TypeId = Guid.NewGuid(),
};
IEnumerable <AdditionalField> additionalFields = new List <AdditionalField>()
{
firstAdditionalFieldExpected,
secondAdditionalFieldExpected
};
var mock = new Mock <IRepository <AdditionalField, TypeEntity> >(MockBehavior.Strict);
mock.Setup(m => m.GetAll()).Returns(additionalFields);
var controller = new AdditionalFieldLogic(mock.Object);
IEnumerable <AdditionalField> resultList = controller.GetAll();
Assert.AreEqual(additionalFields, resultList);
}
public void ValidRangeFormat(AdditionalField additionalField)
{
if (additionalField.Ranges.Count > 0)
{
throw new ExceptionController(LogicExceptions.INVALID_BOOLEAN_RANGE);
}
}
public void RemoveValid()
{
Guid guid = Guid.NewGuid();
AdditionalField additionalField = new AdditionalField()
{
Id = guid,
Name = "Descripcion",
FieldType = "Texto"
};
AdditionalField dummyAdditionalField = new AdditionalField();
dummyAdditionalField.Id = guid;
var mock = new Mock <IRepository <AdditionalField, TypeEntity> >(MockBehavior.Strict);
mock.Setup(m => m.Exist(dummyAdditionalField)).Returns(true);
mock.Setup(m => m.Get(guid)).Returns(additionalField);
mock.Setup(m => m.Remove(additionalField));
mock.Setup(m => m.Save());
var controller = new AdditionalFieldLogic(mock.Object);
controller.Remove(additionalField.Id);
mock.VerifyAll();
}
public Type ToEntity()
{
Type typeAsEntity = new Type()
{
Id = this.Id,
Name = this.Name,
IsActive = this.IsActive,
Topic = new Topic()
{
Id = this.TopicId
},
AdditionalFields = new List <AdditionalField>()
};
if (aFDTOs != null)
{
foreach (AdditionalFieldDTO afDTO in this.aFDTOs)
{
AdditionalField af = afDTO.ToEntity();
af.Type = typeAsEntity;
typeAsEntity.AdditionalFields.Add(af);
}
}
return(typeAsEntity);
}
public void CreateCaseNotExist()
{
Guid firstGuid = Guid.NewGuid();
Guid secondGuid = Guid.NewGuid();
TypeEntity type = new TypeEntity();
type.Id = secondGuid;
AdditionalField additionalField = new AdditionalField()
{
Id = firstGuid,
Name = "Just Testing",
FieldType = "Texto",
Type = type,
TypeId = firstGuid
};
var mock = new Mock <IRepository <AdditionalField, TypeEntity> >(MockBehavior.Strict);
mock.Setup(m => m.GetParent(firstGuid)).Returns(type);
mock.Setup(m => m.Add(It.IsAny <AdditionalField>()));
mock.Setup(m => m.Save());
var controller = new AdditionalFieldLogic(mock.Object);
AdditionalField result = controller.Create(additionalField);
mock.VerifyAll();
Assert.AreEqual(result, additionalField);
}
public List <DateTime> ConvertRangesToDates(AdditionalField additionalField)
{
var FromToDates = new List <DateTime>();
foreach (FieldRange range in additionalField.Ranges)
{
string[] formats = { "MM/dd/yyyy" };
DateTime parsedDateTime;
bool isDate = DateTime.TryParseExact(range.Range,
"MM/dd/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out parsedDateTime);
if (!isDate)
{
throw new ExceptionController(LogicExceptions.WRONG_DATE_FORMAT);
}
FromToDates.Add(parsedDateTime);
}
return(FromToDates);
}
public void AdditionalFieldsControllerUpdateTest()
{
var type = CreateContext();
var fieldId = Guid.NewGuid();
var Logic = CreateLogic();
var Controller = new AdditionalFieldsController(Logic);
AdditionalField field = new AdditionalField()
{
Id = fieldId,
Name = "First AdditionalField",
Type = type,
TypeId = type.Id,
FieldType = "Texto"
};
Logic.Create(field);
AdditionalFieldDTO UpdatedField = new AdditionalFieldDTO()
{
Id = fieldId,
Name = "Updated Field"
};
var result = Controller.Put(fieldId, UpdatedField);
var createdResult = result as CreatedAtRouteResult;
var model = createdResult.Value as AdditionalFieldDTO;
Assert.AreEqual("Updated Field", model.Name);
}
public void CreateInvalidId()
{
Guid firstGuid = Guid.NewGuid();
Guid secondGuid = Guid.NewGuid();
AdditionalField additionalField = new AdditionalField();
additionalField.Id = firstGuid;
additionalField.Name = "New Field Name";
additionalField.TypeId = secondGuid;
additionalField.FieldType = "Texto";
TypeEntity type = new TypeEntity();
type.Name = "New Type";
type.Id = secondGuid;
var mock = new Mock <IRepository <AdditionalField, TypeEntity> >(MockBehavior.Strict);
mock.Setup(m => m.GetParent(secondGuid)).Returns(type);
mock.Setup(m => m.Add(additionalField)).Throws(new ExceptionController());
var controller = new AdditionalFieldLogic(mock.Object);
Assert.ThrowsException <ExceptionController>(() => controller.Create(additionalField));
mock.VerifyAll();
}
public void ValidRangeFormat(AdditionalField additionalField)
{
foreach (FieldRange range in additionalField.Ranges)
{
if (!Regex.IsMatch(range.Range, @"^\d+$"))
{
throw new ExceptionController(LogicExceptions.WRONG_INTEGER_FORMAT + "for the following additional field: " + additionalField.Id);
}
}
if (additionalField.Ranges.Count > 0)
{
/* Valid Date Range */
if (additionalField.Ranges.Count != 2)
{
throw new ExceptionController(LogicExceptions.INVALID_NUMBER_RANGE);
}
var FromToNumbers = ConvertRangesToInts(additionalField);
/* Valid Number Range */
if (FromToNumbers[0] > FromToNumbers[1])
{
throw new ExceptionController(LogicExceptions.INVALID_NUMBER_RANGE);
}
}
}
private void ValidateIntegerRange(AdditionalField addField, AFValue afv)
{
if (addField.Range.Count != 0)
{
int minValue = Int32.Parse(addField.Range[0].Value);
int maxValue = Int32.Parse(addField.Range[1].Value);
bool isInRange = true;
foreach (AFValueItem item in afv.Values)
{
if (isInRange)
{
isInRange = Int32.Parse(item.Value) >= minValue &&
Int32.Parse(item.Value) <= maxValue;
}
else
{
break;
}
}
if (!isInRange)
{
throw new BusinessLogicException($"Error: One Request's additional field value was invalid, check {addField.Name}'s range");
}
}
}
private ICollection <AdditionalFieldValue> CreateFields(AdditionalField field, Guid RequestId, string Value)
{
var selectedValue = new SelectedValues();
selectedValue.Value = Value;
var values = new List <SelectedValues>()
{
selectedValue
};
var fieldValue = new AdditionalFieldValue
{
Id = Guid.NewGuid(),
AdditionalFieldId = field.Id,
Values = values,
RequestId = RequestId
};
List <AdditionalFieldValue> fields = new List <AdditionalFieldValue>()
{
fieldValue
};
return(fields);
}
private void ValidateDateAFV(AdditionalField addFieldById, AFValue afv)
{
if (!IsDateAFV(afv.Values))
{
throw new BusinessLogicException("Error: One Request's additional field value was invalid, check data type");
}
ValidateDateRange(addFieldById, afv);
}
public ActionResult DeleteConfirmed(int id)
{
AdditionalField additionalField = db.AdditionalFields.Find(id);
db.AdditionalFields.Remove(additionalField);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult Get(Guid id)
{
AdditionalField Fields = Logic.Get(id);
if (Fields == null)
{
return(NotFound());
}
return(Ok(AdditionalFieldDTO.ToModel(Fields)));
}
private void ValidateAdditionalFields(Request request)
{
TypeEntity selectedType = GetTypeWithFields(request.TypeId);
if (selectedType == null)
{
throw new ExceptionController(LogicExceptions.INVALID_TYPE_NOT_EXIST);
}
foreach (AdditionalField additionalField in selectedType.AdditionalFields)
{
var fieldExists = request.AdditionalFieldValues.FirstOrDefault(a => a.AdditionalFieldId == additionalField.Id);
if (fieldExists == null)
{
throw new ExceptionController(LogicExceptions.MISSING_REQUIRED_ADDITIONAL_FIELD);
}
}
foreach (AdditionalFieldValue additionalFieldValue in request.AdditionalFieldValues)
{
if (additionalFieldValue.RequestId != request.Id)
{
throw new ExceptionController(LogicExceptions.INVALID_ADDITIONAL_FIELD_REQUEST_ID);
}
AdditionalField selectedAdditionalField = selectedType.AdditionalFields.FirstOrDefault(a => a.Id == additionalFieldValue.AdditionalFieldId);
if (selectedAdditionalField == null)
{
throw new ExceptionController(LogicExceptions.INVALID_ADDITIONAL_FIELD);
}
var valuesObj = additionalFieldValue.Values.GroupBy(x => x.Value);
foreach (var repetition in valuesObj)
{
if (repetition.Count() > 1)
{
throw new ExceptionController(LogicExceptions.REPEATED_SELECTION);
}
}
FieldRangeLogic selectedStrategy = new FieldRangeLogic(selectedAdditionalField.FieldType);
/* MultiSelect Feature Validation */
if (selectedAdditionalField.MultiSelect)
{
selectedStrategy.HasValidRangeValues(selectedAdditionalField, additionalFieldValue);
}
else
{
selectedStrategy.IsValidRangeValue(selectedAdditionalField, additionalFieldValue);
}
}
}
public JsonResult Edit(AdditionalField additionalField)
{
if (ModelState.IsValid)
{
db.Entry(additionalField).State = EntityState.Modified;
db.SaveChanges();
//return RedirectToAction("Index");
}
ViewBag.FleetNo = new SelectList(db.FleetAssets, "FleetNo", "FleetNo", additionalField.FleetNo);
// return View(additionalField);
return(Json(additionalField));
}
public JsonResult Create(AdditionalField additionalField)
{
if (ModelState.IsValid)
{
db.AdditionalFields.Add(additionalField);
db.SaveChanges();
ViewBag.FleetNo = new SelectList(db.FleetAssets, "FleetNo", "RegistrationNo", additionalField.FleetNo);
//return Json("Index");
}
return(Json(additionalField));
}
public AdditionalFieldDTO(AdditionalField af)
{
Id = af.Id;
Name = af.Name;
FieldType = af.FieldType;
Type = af.Type.Id;
RangeDTOs = new List <RangeDTO>();
foreach (AFRangeItem r in af.Range)
{
RangeDTO rangeDTO = new RangeDTO(r);
RangeDTOs.Add(rangeDTO);
}
}
public void IsValidRangeValue(AdditionalField additionalField, AdditionalFieldValue additionalFieldValue)
{
if (additionalFieldValue.Values.Count > 1)
{
throw new ExceptionController(LogicExceptions.INVALID_MULTISELECTION);
}
Boolean boolValue;
if (!Boolean.TryParse(additionalFieldValue.Values.ToList().First().Value, out boolValue))
{
throw new ExceptionController(LogicExceptions.INVALID_BOOLEAN);
}
}
// GET: AdditionalFields/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AdditionalField additionalField = db.AdditionalFields.Find(id);
if (additionalField == null)
{
return(HttpNotFound());
}
return(View(additionalField));
}
// GET: AdditionalFields/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AdditionalField additionalField = db.AdditionalFields.Find(id);
if (additionalField == null)
{
return(HttpNotFound());
}
ViewBag.FleetNo = new SelectList(db.FleetAssets, "FleetNo", "FleetNo", additionalField.FleetNo);
return(View(additionalField));
}
public void IsValidRangeValue(AdditionalField additionalField, AdditionalFieldValue additionalFieldValue)
{
if (additionalFieldValue.Values.Count > 1)
{
throw new ExceptionController(LogicExceptions.INVALID_MULTISELECTION);
}
/* Validate Value Within Ranges */
DateTime incomingDate = ConvertStringToDate(additionalFieldValue.Values.ToList().First().Value);
var FromToDates = ConvertRangesToDates(additionalField);
if (!(incomingDate >= FromToDates[0] && incomingDate <= FromToDates[1]))
{
throw new ExceptionController(LogicExceptions.DATE_OUT_OF_RANGE);
}
}
public void GetIsNotOk()
{
Guid guid = Guid.NewGuid();
AdditionalField dummyAdditionalField = new AdditionalField();
dummyAdditionalField.Id = guid;
var mock = new Mock <IRepository <AdditionalField, TypeEntity> >(MockBehavior.Strict);
mock.Setup(m => m.Exist(dummyAdditionalField)).Returns(true);
mock.Setup(m => m.Get(guid)).Throws(new ExceptionController());
var controller = new AdditionalFieldLogic(mock.Object);
Assert.ThrowsException <ExceptionController>(() => controller.Get(guid));
mock.VerifyAll();
}
public void AdditionalFieldControllerPostTestWithRanges()
{
var id = Guid.NewGuid();
var type = CreateContext();
var Logic = CreateLogic();
var Controller = new AdditionalFieldsController(Logic);
var AdditionalField = new AdditionalField
{
Id = id,
Name = "First AdditionalField",
Type = type,
TypeId = type.Id,
FieldType = "Texto"
};
FieldRange range = new FieldRange()
{
AdditionalFieldId = id,
Range = "Range 1"
};
FieldRange range2 = new FieldRange()
{
AdditionalFieldId = id,
Range = "Range 2"
};
FieldRange range3 = new FieldRange()
{
AdditionalFieldId = id,
Range = "Range 3"
};
var RangeList = new List <FieldRange>()
{
range, range2, range3
};
AdditionalField.Ranges = RangeList;
var result = Controller.Post(AdditionalFieldDTO.ToModel(AdditionalField));
var createdResult = result as CreatedAtRouteResult;
var model = createdResult.Value as AdditionalFieldDTO;
Assert.AreEqual(AdditionalField.Ranges.Count, model.Ranges.Count);
}
private AdditionalField CreateFieldLogic(TypeEntity type)
{
var additionalFieldRepo = new AdditionalFieldRepository(Context);
var additionalFieldLogic = new AdditionalFieldLogic(additionalFieldRepo);
AdditionalField field = new AdditionalField()
{
Id = Guid.NewGuid(),
Name = "Celular de Contacto",
Type = type,
FieldType = "Texto",
TypeId = type.Id
};
additionalFieldLogic.Create(field);
return(field);
}
public void IsValidRangeValue(AdditionalField additionalField, AdditionalFieldValue additionalFieldValue)
{
if (additionalFieldValue.Values.Count > 1)
{
throw new ExceptionController(LogicExceptions.INVALID_MULTISELECTION);
}
if (additionalField.Ranges.Count > 0)
{
FieldRange field = new FieldRange();
field.Range = additionalFieldValue.Values.ToList().First().Value;
if (!additionalField.Ranges.Contains(field))
{
throw new ExceptionController(LogicExceptions.INVALID_ADDITIONAL_FIELD_RANGES);
}
}
}
