public ProjectOptions CreateProject(ProjectOptions projectOptions)
{
var user = dbContext.Set <User>().Where(u => u.Id == projectOptions.CreatorId).Include(p => p.CreatedProjects).SingleOrDefault();
var project = new Project()
{
CreatorId = projectOptions.CreatorId,
Description = projectOptions.Description,
Category = projectOptions.Category,
Photo = projectOptions.Photo,
Video = projectOptions.Video,
Goal = projectOptions.Goal,
Title = projectOptions.Title,
Status = projectOptions.Status
};
user.CreatedProjects.Add(project);
dbContext.Update(user);
dbContext.SaveChanges();
return(new ProjectOptions()
{
Id = project.Id,
CreatorId = project.CreatorId,
CurrentFund = project.CurrentFund,
Description = project.Description,
Category = project.Category,
Photo = project.Photo,
Video = project.Video,
Goal = project.Goal,
Title = project.Title,
Status = project.Status,
TimesFunded = project.TimesFunded
});
}
public Funding BuyPackageByUserId(int userId, int packageId)
{
var user = dbContext.Set <User>().Where(u => u.Id == userId).Include(f => f.Fundings).SingleOrDefault();
var fundingExists = dbContext.Set <Funding>().Where(u => u.UserId == userId).Where(p => p.PackageId == packageId).SingleOrDefault();
if (fundingExists == null)
{
var newFund = new Funding()
{
PackageId = packageId, UserId = userId
};
var package = dbContext.Set <Package>().Where(p => p.Id == packageId).Include(p => p.Project).SingleOrDefault();
var project = dbContext.Set <Project>().Find(package.ProjectId);
project.CurrentFund += package.Price;
project.TimesFunded += 1;
user.Fundings.Add(newFund);
dbContext.Update(user);
dbContext.Update(project);
dbContext.SaveChanges();
return(newFund);
}
else
{
return(null);
}
}
public RewardPackageOption CreateRewardPackage(RewardPackageOption rewardPackageOption)
{
RewardPackage rewardPackage = GetRewardPackageFromRewardPackageOption(rewardPackageOption);
dbContext.RewardPackages.Add(rewardPackage);
dbContext.SaveChanges();
rewardPackageOption.Id = rewardPackage.Id;
return(rewardPackageOption);
}
public RewardPackageOption AddPackageToProject(int projectId, int rewardPackageId)
{
var project = db.Set <Project>().Find(projectId);
var rewardPackage = db.Set <RewardPackage>().Find(rewardPackageId);
project.RewardPackages.Add(rewardPackage);
rewardPackage.Project = project;
db.SaveChanges();
return(new RewardPackageOption()
{
Price = rewardPackage.Price,
ProjectId = project.Id,
Reward = rewardPackage.Reward
});
}
public BackerOption CreateBacker(BackerOption backerOption)
{
Backer backer = new Backer
{
FirstName = backerOption.FirstName,
LastName = backerOption.LastName,
Email = backerOption.Email
};
dbContext.Backers.Add(backer);
dbContext.SaveChanges();
return(new BackerOption
{
FirstName = backerOption.FirstName,
LastName = backerOption.LastName,
Email = backer.Email
});
}
public ProjectCreatorOption CreateProjectCreator(ProjectCreatorOption pcOption)
{
ProjectCreator pc = new ProjectCreator
{
FirstName = pcOption.FirstName,
LastName = pcOption.LastName,
Description = pcOption.Description,
Email = pcOption.Email
};
dbContext.ProjectCreators.Add(pc);
dbContext.SaveChanges();
return(new ProjectCreatorOption
{
FirstName = pc.FirstName,
LastName = pc.LastName,
Description = pc.Description,
Email = pc.Email,
Id = pc.Id
});
}
public MediaOption CreateMedia(MediaOption mediaOption)
{
Project project = db.Set <Project>().Where(o => o.Id == mediaOption.ProjectId).Include(o => o.Medias).SingleOrDefault();
Media media = new Media()
{
Payload = mediaOption.Payload,
Type = mediaOption.Type,
Project = project
};
var newMedia = db.Set <Media>().Add(media);
db.SaveChanges();
project.Medias.Add(newMedia.Entity);
db.SaveChanges();
return(new MediaOption()
{
Payload = media.Payload,
Type = media.Type,
ProjectId = mediaOption.ProjectId
});
}
public TransactionOption CreateTransaction(int backerId, int rewardPackageOptionId)
{
if (backerId == 0)
{
return(null);
}
Backer backer = dbContext.Backers.Find(backerId);
if (backer == null)
{
return(null);
}
RewardPackage rewardPackage = dbContext.RewardPackages.Where(o => o.Id == rewardPackageOptionId).Include(o => o.Project).SingleOrDefault();
if (rewardPackage == null)
{
return(null);
}
Transaction transaction = new Transaction {
Backer = backer, RewardPackage = rewardPackage, Amount = rewardPackage.Price
};
dbContext.Transactions.Add(transaction);
dbContext.SaveChanges();
TransactionOption transactionOption = new TransactionOption
{
BackerName = backer.LastName + " " + backer.FirstName + " ",
TransactionId = transaction.Id,
BackerId = backer.Id,
Amount = transaction.Amount,
ProjectName = transaction.RewardPackage.Project.Title,
RewardPackage = AddRewardPackageToTransaction(rewardPackageOptionId)
};
return(UpdateCurrentBudget(transactionOption));
}
public StatusUpdateOption AddStatusUpdate(StatusUpdateOption statusUpdateOption)
{
Project project = db.Set <Project>().Find(statusUpdateOption.ProjectId);
StatusUpdate statusUpdate = new StatusUpdate()
{
Overload = statusUpdateOption.Payload,
Timestamp = statusUpdateOption.Timestamp,
Project = project
};
project.StatusUpdates.Add(statusUpdate);
db.Set <StatusUpdate>().Add(statusUpdate);
db.SaveChanges();
return(statusUpdateOption);
}
public PackageOptions AddPackageToProject(PackageOptions packageOptions, int projectId)
{
var project = dbContext.Set <Project>()
.Where(p => p.Id == projectId)
.Include(pac => pac.Packages)
.SingleOrDefault();
var package = new Package()
{
Price = packageOptions.Price,
ProjectId = projectId,
Reward = packageOptions.Reward
};
project.Packages.Add(package);
dbContext.Update(project);
dbContext.SaveChanges();
return(new PackageOptions()
{
Id = package.Id,
Price = package.Price,
ProjectId = package.ProjectId,
Reward = package.Reward
});
}
public Result <Project> CreateProject(CreateProjectOptions options)
{
if (options == null)
{
return(Result <Project>
.CreateFailed(StatusCode.BadRequest, "Null options"));
}
var user = userService.SearchUser(new SearchUserOptions()
{
UserId = options.UserId
}).Include(u => u.Projects)
.ThenInclude(p => p.Packages)
.SingleOrDefault();
if (user == null)
{
return(Result <Project>
.CreateFailed(StatusCode.BadRequest, $"The UserId {options.UserId} does not exist"));
}
if (IsValidProjectOptions(options))
{
Project project = new Project();
project.Title = options.Title;
project.Description = options.Description;
project.Category = options.Category;
project.FinancialGoal = options.FinancialGoal;
foreach (var url in options.MediaUrls)
{
if (!string.IsNullOrWhiteSpace(url))
{
project.Media.Add(new ProjectMedia()
{
MediaUrl = url
});
}
}
user.Projects.Add(project);
user.IsProjectCreator = true;
try
{
if (dbContext.SaveChanges() > 0)
{
return(Result <Project>
.CreateSuccessful(project));
}
else
{
return(Result <Project>
.CreateFailed(StatusCode.InternalServerError, "Project could not be made"));
}
}
catch (Exception ex)
{
return(Result <Project>
.CreateFailed(StatusCode.InternalServerError, ex.ToString()));
}
}
return(Result <Project>
.CreateFailed(StatusCode.InternalServerError, "Project options are not valid"));
}
public Result <User> CreateUser(CreateUserOptions options)
{
if (options == null)
{
return(Result <User>
.CreateFailed(StatusCode.BadRequest, "Null options"));
}
var user = new User();
if (!string.IsNullOrWhiteSpace(options.FirstName))
{
user.FirstName = options.FirstName;
}
else
{
return(Result <User>
.CreateFailed(StatusCode.BadRequest, "First name was null or empty"));
}
if (!string.IsNullOrWhiteSpace(options.LastName))
{
user.LastName = options.LastName;
}
else
{
return(Result <User>
.CreateFailed(StatusCode.BadRequest, "Last name was null or empty"));
}
if (string.IsNullOrWhiteSpace(options.Email))
{
return(Result <User>
.CreateFailed(StatusCode.BadRequest, "Email was null or empty"));
}
options.Email = options.Email.Trim();
if (IsValidEmail(options.Email))
{
user.Email = options.Email;
}
else
{
return(Result <User>
.CreateFailed(StatusCode.BadRequest, "Email submitted was not a valid email address"));
}
dbContext.Add(user);
try
{
if (dbContext.SaveChanges() > 0)
{
return(Result <User>
.CreateSuccessful(user));
}
else
{
return(Result <User>
.CreateFailed(StatusCode.InternalServerError, "User could not be created"));
}
}
catch (Exception ex)
{
return(Result <User>
.CreateFailed(StatusCode.InternalServerError, ex.ToString()));
}
}
public Result <Package> CreatePackage(CreatePackageOptions options)
{
if (options == null)
{
return(Result <Package>
.CreateFailed(StatusCode.BadRequest, "Null options"));
}
var project = projectService.SearchProject(new SearchProjectOptions()
{
ProjectId = options.ProjectId
}).SingleOrDefault();
if (project == null)
{
return(Result <Package>
.CreateFailed(StatusCode.BadRequest, $"The ProjectId {options.ProjectId} does not exist"));
}
var package = new Package();
if (!string.IsNullOrWhiteSpace(options.Description))
{
package.Description = options.Description;
}
else
{
return(Result <Package>
.CreateFailed(StatusCode.BadRequest, $"Package description is empty"));
}
if (options.Price > 0M)
{
package.Price = (decimal)options.Price;
}
else
{
return(Result <Package>
.CreateFailed(StatusCode.BadRequest, $"Price is not valid"));
}
project.Packages.Add(package);
try
{
if (dbContext.SaveChanges() > 0)
{
return(Result <Package>
.CreateSuccessful(package));
}
else
{
return(Result <Package>
.CreateFailed(StatusCode.InternalServerError, "Package could not be created"));
}
}
catch (Exception ex)
{
return(Result <Package>
.CreateFailed(StatusCode.InternalServerError, ex.ToString()));
}
}
