/// <summary>
/// Default constructor which also registers the fields required by this updater
/// </summary>
public InitialOrderParent()
{
spawnOrder = 0;
RequiredFields.Add(ParticleFields.Order);
}
public BeamPostUpdate()
{
RequiredFields.Add(ParticleFields.Position);
RequiredFields.Add(ParticleFields.Velocity);
RequiredFields.Add(ParticleFields.RandomSeed);
}
public SalesOrder()
{
IgnoreProperties.Add(nameof(orderNo));
IgnoreProperties.Add("orderNumber");
RequiredFields.Add(nameof(orderType), new DtoValue("SO"));
}
/// <summary>
/// Default constructor which also registers the fields required by this updater
/// </summary>
public InitialColorParent()
{
RequiredFields.Add(ParticleFields.Color);
RequiredFields.Add(ParticleFields.RandomSeed);
}
/// <summary>
/// Default constructor which also registers the fields required by this updater
/// </summary>
public InitialSpawnOrderGroup()
{
spawnOrder = 0;
RequiredFields.Add(ParticleFields.Order);
}
public UpdaterSpeedToDirection()
{
RequiredFields.Add(ParticleFields.Position);
RequiredFields.Add(ParticleFields.OldPosition);
RequiredFields.Add(ParticleFields.Direction);
}
public Address()
{
RequiredFields.Add("county", new DtoValue(null));
}
/// <summary>
/// Default key deserializer
/// </summary>
void IBigtableKeySerializer <object> .DeserializeKey(object instance, byte[] keyBytes, Encoding encoding)
{
if (instance == null)
{
throw new InvalidOperationException("Can not deserialize keys on a null reference of type " + _type.SimpleName());
}
// Locals
//var bytes = new List<byte[]>();
var separator = encoding.GetBytes(KeyFieldSeparator);
var keys = new List <byte[]>();
// This is not pretty.
// TODO: Is there a better way?
// Split key
var prevIndex = 0;
for (int index = 0; index < keyBytes.Length; index++)
{
var foundKey = true;
for (int kIndex = 0; kIndex < separator.Length; kIndex++)
{
if (keyBytes[index + kIndex] != separator[kIndex])
{
foundKey = false;
break;
}
}
if (foundKey || index == keyBytes.Length - 1)
{
// TODO: Account for multibyte separators
var size = index == keyBytes.Length - 1 ? keyBytes.Length - prevIndex : index - prevIndex;
var key = new byte[size]; // mmmm, byte sized
// A zero byte key is okay, and must be accounted
// in order for the key deserialer to find the right slots
if (size > 0)
{
Array.Copy(keyBytes, prevIndex, key, 0, size);
}
keys.Add(key);
index += separator.Length;
prevIndex = index;
}
}
// Ensure we have some key data
if (!keys.Any())
{
throw new SerializationException("No keys found while deserializing " + _type.SimpleName());
}
// Populate the key fields on the POCO
for (int index = 0; index < KeyFields.Length; index++)
{
// Localize
var fieldName = KeyFields[index];
var required = RequiredFields.Contains(fieldName);
// Are there more key fields than we have keys?
if (index >= keys.Count)
{
// No more key bytes available, was this required?
if (required)
{
throw new KeyNotFoundException(String.Format("Member {0} on type {1} is marked as required but is missing in the deserialization stream.", FieldNameLookup[fieldName], _type));
}
// Non-required field, continue to check the rest of the fields
continue;
}
// Localize this key's value
var valueBytes = keys[index];
//var value = Getters[field](instance);
// Missing value?
if (valueBytes == null)
{
if (required)
{
throw new SerializationException(String.Format("Member {0} on type {1} is marked as required but was not specified", FieldNameLookup[fieldName], _type));
}
// Continue to next key field
continue;
}
// Get destination type
var valueType = MemberTypes[fieldName];
// Find a serializer for this type
var serializer = GetSerializerForType(valueType);
// Deserialize
var value = serializer.DeserializeField(valueType, valueBytes, TableEncoding);
// Store value
Setters[fieldName](instance, value);
}
}
/// <summary>
/// Default key serializer
/// </summary>
byte[] IBigtableKeySerializer <object> .SerializeKey(object instance, Encoding encoding)
{
// Contract
if (instance == null)
{
throw new InvalidOperationException("Can not serialize keys on a null reference.");
}
// Locals
//bool missingKey = false;
var bytes = new List <byte[]>();
var separator = encoding.GetBytes(KeyFieldSeparator);
// Iterate keys
for (int index = 0; index < KeyFields.Length; index++)
{
// Localize
var fieldName = KeyFields[index];
var required = RequiredFields.Contains(fieldName);
var value = Getters[fieldName](instance);
//
if (value == null)
{
if (required)
{
throw new SerializationException(String.Format("The member {0} on type {1} is marked as required but was not specified", FieldNameLookup[fieldName], _type));
}
bytes.Add(separator);
//missingKey = true;
continue;
}
//if (missingKey)
//{
// // Programmer exception
// var exception = new MissingFieldException(_type.Name, memberName);
// // User exception // TODO: I think I designed around this
// throw new SerializationException("The default serializer insists that the primary keys are filled in order. Missing keys are okay as long as all subsequent keys are missing as well.", exception);
//}
var valueType = value.GetType();
var serializer = GetSerializerForType(valueType);
if (IsBigBoxed[fieldName])
{
if (!IsSpecified[fieldName](instance))
{
bytes.Add(new byte[0]);
continue;
}
//var fieldType = MemberTypes[memberName];
//var access = GetKeyAccess(fieldType);
//value = access.ValueGetter(value);
}
var serialized = serializer.SerializeField(valueType, value, TableEncoding);
bytes.Add(serialized);
}
var bytesSize = bytes.Count - 1;
var sepLength = (bytesSize) * separator.Length;
var results = new byte[sepLength + bytes.Sum(b => b.Length)];
var ptr = 0;
for (int index = 0; index < bytes.Count; index++)
{
// Get field bytes
var source = bytes[index];
// Copy to result array in correct position
Array.Copy(source, 0, results, ptr, source.Length);
// Move ptr forward
ptr += source.Length;
if (index < bytesSize)
{
// Copy in separator
Array.Copy(separator, 0, results, ptr, sepLength);
// Move ptr foward
ptr += sepLength;
}
}
// Tada!
return(results);
}
public async Task <IActionResult> Store([FromForm] CourseOutlineRequest request)
{
try
{
if (_userRepository.LogCurrentUser().canCreate == false)
{
return(Unauthorized(_UnAuthorized));
}
CourseOutline model = new CourseOutline();
model.title = request.title;
model.courseId = request.courseId;
model.userGroupId = request.userGroupId;
model.visibility = request.visibility;
model.duration = request.duration;
model.description = request.description;
model.Course = request.Course;
model.UserGroup = request.UserGroup;
RequiredFields modelRequest = new RequiredFields();
modelRequest.CourseOutline = model;
object validateFields = _validationService.ValidateRequest("Course Outline", modelRequest);
if (JsonConvert.SerializeObject(validateFields).Length > 2)
{
return(BadRequest(validateFields));
}
var checkExists = _context.CourseOutline.Where(x => x.title == request.title && x.courseId == request.courseId).Any();
if (checkExists == true)
{
return(BadRequest(new GenericResult {
Response = false, Message = request.title + " is already exists"
}));
}
if (request.featureImage != null)
{
if (request.featureImage.Length > 0)
{
Stream stream = request.featureImage.OpenReadStream();
var path = Path.Combine(_hostingEnvironment.WebRootPath, _fileDirectory.virtualDirectory);
string courseOutlineImageFolder = String.Format("{0}\\Content\\Images\\CourseOutline", path);
if (!Directory.Exists(courseOutlineImageFolder))
{
Directory.CreateDirectory(courseOutlineImageFolder);
}
var id = Guid.NewGuid();
var extension = Path.GetExtension(request.featureImage.FileName);
var fileName = id.ToString() + extension.ToString().ToLower();
using (var zipStream = new FileStream(Path.Combine(courseOutlineImageFolder, fileName), FileMode.Create))
{
request.featureImage.CopyTo(zipStream);
}
model.featureImage = fileName;
}
}
if (request.interactiveVideo != null)
{
if (request.interactiveVideo.Length > 0)
{
Stream stream = request.interactiveVideo.OpenReadStream();
var path = Path.Combine(_hostingEnvironment.WebRootPath, _fileDirectory.virtualDirectory);
string courseOutlineVideoFolder = String.Format("{0}\\Content\\Video\\CourseOutline", path);
if (!Directory.Exists(courseOutlineVideoFolder))
{
Directory.CreateDirectory(courseOutlineVideoFolder);
}
var idVideo = Guid.NewGuid();
var extension = Path.GetExtension(request.interactiveVideo.FileName);
var fileNameVideo = idVideo.ToString() + extension.ToString().ToLower();
model.interactiveVideo = idVideo.ToString();
using (var zipStream = new FileStream(Path.Combine(courseOutlineVideoFolder, fileNameVideo), FileMode.Create))
{
request.interactiveVideo.CopyTo(zipStream);
using (var archive = new ZipArchive(zipStream, ZipArchiveMode.Read))
{
archive.ExtractToDirectory(Path.Combine(courseOutlineVideoFolder, idVideo.ToString()));
}
}
}
}
_context.CourseOutline.Add(model);
await _context.SaveChangesAsync();
// start: Course Outline Prerequisite
if (request.CourseOutlinePrerequisite != null)
{
for (int copKey = 0; request.CourseOutlinePrerequisite.Count() > copKey; copKey++)
{
CourseOutlinePrerequisite copModel = new CourseOutlinePrerequisite();
copModel.courseOutlineId = model.id;
copModel.courseId = request.courseId;
copModel.preRequisiteId = request.CourseOutlinePrerequisite[copKey].preRequisiteId;
_context.CourseOutlinePrerequisite.Add(copModel);
await _context.SaveChangesAsync();
}
}
// start: Course Outline Milestone
if (request.CourseOutlineMilestone != null)
{
for (int comKey = 0; request.CourseOutlineMilestone.Count() > comKey; comKey++)
{
CourseOutlineMilestone comModel = new CourseOutlineMilestone();
comModel.courseOutlineId = model.id;
comModel.courseId = request.courseId;
comModel.name = request.CourseOutlineMilestone[comKey].name;
comModel.lessonCompleted = request.CourseOutlineMilestone[comKey].lessonCompleted;
if (request.CourseOutlineMilestoneResourceFile != null)
{
if (request.CourseOutlineMilestoneResourceFile[comKey].Length > 0)
{
Stream stream = request.CourseOutlineMilestoneResourceFile[comKey].OpenReadStream();
var path = Path.Combine(_hostingEnvironment.WebRootPath, _fileDirectory.virtualDirectory);
string courseOutlineMilestoneVideoFolder = String.Format("{0}\\Content\\Video\\CourseOutlineMilestone", path);
if (!Directory.Exists(courseOutlineMilestoneVideoFolder))
{
Directory.CreateDirectory(courseOutlineMilestoneVideoFolder);
}
var milestoneId = Guid.NewGuid();
var extension = Path.GetExtension(request.CourseOutlineMilestoneResourceFile[comKey].FileName);
var milestoneFileName = milestoneId.ToString() + extension.ToString().ToLower();
using (var zipStream = new FileStream(Path.Combine(courseOutlineMilestoneVideoFolder, milestoneFileName), FileMode.Create))
{
request.CourseOutlineMilestoneResourceFile[comKey].CopyTo(zipStream);
}
comModel.resourceFile = milestoneFileName;
}
}
_context.CourseOutlineMilestone.Add(comModel);
await _context.SaveChangesAsync();
}
}
// start: Course Outline Media
if (request.CourseOutlineMediaFile != null)
{
for (int cofKey = 0; request.CourseOutlineMediaFile.Count() > cofKey; cofKey++)
{
CourseOutlineMedia cofModel = new CourseOutlineMedia();
cofModel.courseOutlineId = model.id;
cofModel.courseId = request.courseId;
if (request.CourseOutlineMediaFile[cofKey].Length > 0)
{
Stream stream = request.CourseOutlineMediaFile[cofKey].OpenReadStream();
var path = Path.Combine(_hostingEnvironment.WebRootPath, _fileDirectory.virtualDirectory);
string courseOutlineMediaFolder = String.Format("{0}\\Content\\Video\\CourseOutlineMedia", path);
if (!Directory.Exists(courseOutlineMediaFolder))
{
Directory.CreateDirectory(courseOutlineMediaFolder);
}
var mediaId = Guid.NewGuid();
var extension = Path.GetExtension(request.CourseOutlineMediaFile[cofKey].FileName);
var mediaFileName = mediaId.ToString() + extension.ToString().ToLower();
using (var zipStream = new FileStream(Path.Combine(courseOutlineMediaFolder, mediaFileName), FileMode.Create))
{
request.CourseOutlineMediaFile[cofKey].CopyTo(zipStream);
}
cofModel.resourceFile = mediaFileName;
}
_context.CourseOutlineMedia.Add(cofModel);
await _context.SaveChangesAsync();
}
}
return(Ok(new GenericResult {
Response = true, Message = request.title + " has been successfully created"
}));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
