/// <summary>
/// Create a new <see cref="ConceptionDevisWS.Models.Model"/> for an existing <see cref="ConceptionDevisWS.Models.Range"/>.
/// </summary>
/// <param name="rangeId">the range's identity</param>
/// <param name="newModel">the model to store</param>
/// <param name="lang">the culture to create the model into (fr-FR or en-US)</param>
/// <returns>the stored model</returns>
/// <exception cref="HttpResponseException">In case something went wrong (when the given range does not exists or the model is null).</exception>
public async static Task <Model> CreateNew(int rangeId, Model newModel, string lang)
{
if (newModel == null || newModel.Name == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
Range seekedRange = await _searchRange(rangeId, lang);
newModel.Range = seekedRange;
if (!await Validate(rangeId, newModel))
{
string errMsg = "Invalid content : The model ExternalFinishing or FrameQuality does not match its Range.";
HttpResponseMessage responseMessage = new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, Content = new StringContent(errMsg)
};
throw new HttpResponseException(responseMessage);
}
using (ModelsDBContext ctx = new ModelsDBContext())
{
List <Expression <Func <Range, object> > > modelsExpr = new List <Expression <Func <Range, object> > >();
await ServiceHelper <Model> .LoadSingleNavigationProperty <Range>(newModel, ctx, m => m.Range, _getCtxRanges, modelsExpr, _setRange);
ctx.Models.Add(newModel);
await ctx.SaveChangesAsync();
return(newModel);
}
}
public static Articles searchArticle(ModelsDBContext db, int id)
{
Articles article = new Articles();
article = db.Article.Find(id);
return(article);
}
/// <summary>
/// Update completely an <see cref="ConceptionDevisWS.Models.User"/>.
/// </summary>
/// <param name="id">the user's identity</param>
/// <param name="newUser">the updated user</param>
/// <param name="lang">the culture to update this user into (fr-FR or en-US)</param>
/// <returns>the updated user</returns>
/// <exception cref="HttpResponseException">In case something went wront (for example the requested user doesn't exist).</exception>
public async static Task <User> UpdateUser(int id, User newUser, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
User seekedUser = await GetUser(id, lang);
ctx.Entry(seekedUser).State = EntityState.Modified;
ctx.Entry(seekedUser).Collection(u => u.Clients).EntityEntry.State = EntityState.Modified;
await ServiceHelper <User> .UpdateNavigationProperty <Client>(newUser, seekedUser, ctx, _getClients, _getCtxClients);
seekedUser.UpdateNonComposedPropertiesFrom(newUser);
bool updateSuccess = false;
do
{
try
{
await ctx.SaveChangesAsync();
updateSuccess = true;
}
catch (DbUpdateConcurrencyException dbuce)
{
DbEntityEntry entry = dbuce.Entries.Single();
entry.OriginalValues.SetValues(await entry.GetDatabaseValuesAsync());
}
} while (!updateSuccess);
return(seekedUser);
}
}
/// <summary>
/// Retrieve a <see cref="ConceptionDevisWS.Models.Client"/>'s <see cref="ConceptionDevisWS.Models.Project"/>.
/// </summary>
/// <param name="clientId">the client's identity</param>
/// <param name="id">the project's identity</param>
/// <param name="lang">the culture to get the project into (fr-FR or en-US)</param>
/// <returns>a project</returns>
/// <exception cref="HttpResponseException">In case either the client or project doesn't exist.</exception>
public async static Task <Project> GetClientProject(int clientId, int id, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
return(await _searchClientProject(clientId, id, lang));
}
}
public AccountController(UserManager <User> userManager,
SignInManager <User> signInManager, ModelsDBContext context)
{
_signManager = signInManager;
_userManager = userManager;
_context = context;
}
/// <summary>
/// Internal use only, Update completely a given <see cref="ConceptionDevisWS.Models.Project"/> Including its <see cref="ConceptionDevisWS.Models.Client"/>.
/// </summary>
/// <param name="originalClientId">the original client's identity</param>
/// <param name="newClientId">the new client's identity</param>
/// <param name="id">the project's identity</param>
/// <param name="newProject">the updated project (possibly with a different client) </param>
/// <param name="lang">the culture to udpate the project into (fr-FR or en-US)</param>
/// <returns>the updated project</returns>
/// <exception cref="HttpResponseException">In case either the client or project doesn't exist.</exception>
public async static Task <Project> SpecialUpdateProject(int originalClientId, int newClientId, int id, Project newProject, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
if (newProject.Client == null)
{
newProject.Client = new Client();
}
newProject.Client.Id = newClientId;
if (newProject == null || newProject.Name == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
Project seekedProject = await _searchClientProject(originalClientId, id, lang);
ctx.Entry(seekedProject).State = EntityState.Modified;
List <Expression <Func <Client, object> > > usersExpr = new List <Expression <Func <Client, object> > > ();
await ServiceHelper <Project> .SetSingleNavigationProperty <Client>(newProject, seekedProject, ctx, p => p.Client, _getCtxClients, usersExpr, _setClient);
seekedProject.UpdateNonComposedPropertiesFrom(newProject);
await ctx.SaveChangesAsync();
return(seekedProject);
}
}
/// <summary>
/// Update completely the given <see cref="ConceptionDevisWS.Models.Range"/>.
/// </summary>
/// <param name="id">the range's identity</param>
/// <param name="newRange">the updated range to store</param>
/// <param name="lang">the culture to update this range into (fr-FR or en-US)</param>
/// <returns>the updated range</returns>
/// <exception cref="HttpResponseException">In case something went wrong (for example, when the requested range does not exists).</exception>
public async static Task <Range> UpdateRange(int id, Range newRange, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Range seekedRange = await GetRange(id, lang);
ctx.Entry(seekedRange).State = EntityState.Modified;
ctx.Entry(seekedRange).Collection(r => r.Models).EntityEntry.State = EntityState.Modified;
await ServiceHelper <Range> .UpdateNavigationProperty <Model>(newRange, seekedRange, ctx, _getModels, _getCtxModels);
seekedRange.UpdateNonComposedPropertiesFrom(newRange);
bool updateSuccess = false;
do
{
try
{
await ctx.SaveChangesAsync();
updateSuccess = true;
}
catch (DbUpdateConcurrencyException dbuce)
{
DbEntityEntry entry = dbuce.Entries.Single();
entry.OriginalValues.SetValues(await entry.GetDatabaseValuesAsync());
}
} while (!updateSuccess);
return(seekedRange);
}
}
public async static Task <Client> GetMaderaClient()
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
return(await ctx.Clients.FirstAsync(c => c.FirstName == "Madera" && c.ZipCode == -1));
}
}
public async static Task <Product> CreateNew(Product newProduct, string lang)
{
if (newProduct == null || newProduct.Name == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
CulturalEnumStringConverter.Culture = new CultureInfo(lang);
using (ModelsDBContext ctx = new ModelsDBContext())
{
if (newProduct.Graphic != null && newProduct.Graphic.Length > 4000)
{
newProduct.Graphic = "";
}
List <Expression <Func <Model, object> > > rangesExpr = new List <Expression <Func <Model, object> > > {
m => m.Range,
m => m.Modules.Select(mod => mod.Components)
};
await ServiceHelper <Product> .LoadSingleNavigationProperty <Model>(newProduct, ctx, p => p.Model, _getCtxModels, rangesExpr, _setModel);
ctx.Products.Add(newProduct);
await ctx.SaveChangesAsync();
return(newProduct);
}
}
public static List <Articles> showIndexModel(ModelsDBContext db, string context)
{
List <Articles> articles = new List <Articles>();
articles = db.Article.Where(p => p.Areas.Equals(context)).ToList();
return(articles);
}
/// <summary>
/// Update a given module
///
/// only components associations can be updated
/// </summary>
/// <param name="id">the module's identity</param>
/// <param name="newModule">the updated module to store</param>
/// <param name="lang">the culture to update the module into (fr-FR or en-US)</param>
/// <returns>the updated module</returns>
public async static Task <Module> UpdateModule(int id, Module newModule, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Module seekedModule = await GetModule(id, lang);
ctx.Entry(seekedModule).State = EntityState.Modified;
ctx.Entry(seekedModule).Collection(mod => mod.Components).EntityEntry.State = EntityState.Modified;
await ServiceHelper <Module> .UpdateNavigationProperty <Component>(newModule, seekedModule, ctx, _getComposants, _getContextComponents);
seekedModule.UpdateNonComposedPropertiesFrom(newModule);
bool updateSuccess = false;
do
{
try
{
int affectedRows = await ctx.SaveChangesAsync();
updateSuccess = true;
} catch (DbUpdateConcurrencyException dbuce)
{
DbEntityEntry entry = dbuce.Entries.Single();
entry.OriginalValues.SetValues(await entry.GetDatabaseValuesAsync());
}
} while (!updateSuccess);
return(seekedModule);
}
}
/// <summary>
/// Update completely the given <see cref="ConceptionDevisWS.Models.Client"/>.
/// </summary>
/// <param name="id">the client's identity</param>
/// <param name="newClient">the updated client to store</param>
/// <returns>the updated client</returns>
/// <exception cref="HttpResponseException">In case something went wrong (for example, when the requested client does not exists).</exception>
public async static Task <Client> UpdateClient(int id, Client newClient)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
bool updateSuccess = false;
Client seekedClient = await GetClient(id);
ctx.Entry(seekedClient).State = EntityState.Modified;
ctx.Entry(seekedClient).Collection(c => c.Projects).EntityEntry.State = EntityState.Modified;
ctx.Entry(seekedClient).Reference(c => c.User).EntityEntry.State = EntityState.Modified;
await ServiceHelper <Client> .UpdateNavigationProperty <Project>(newClient, seekedClient, ctx, _getProjects, _getCtxProjects);
seekedClient.UpdateNonComposedPropertiesFrom(newClient);
do
{
try
{
await ctx.SaveChangesAsync();
updateSuccess = true;
} catch (DbUpdateConcurrencyException dbuce)
{
DbEntityEntry entry = dbuce.Entries.Single();
entry.OriginalValues.SetValues(await entry.GetDatabaseValuesAsync());
}
} while (!updateSuccess);
return(seekedClient);
}
}
/// <summary>
/// Retrieve all existing <see cref="ConceptionDevisWS.Models.Module"/>s with their <see cref="ConceptionDevisWS.Models.Component"/>s.
/// </summary>
/// <param name="lang">the culture to get the modules into (fr-FR or en-US)</param>
/// <returns>a list of modules</returns>
public async static Task <IEnumerable <Module> > GetAllModules(string lang)
{
CulturalEnumStringConverter.Culture = new CultureInfo(lang);
using (ModelsDBContext ctx = new ModelsDBContext())
{
return(await ctx.Modules.Include(m => m.Components).ToListAsync());
}
}
public async static Task <List <Product> > GetAllProducts(string lang)
{
CulturalEnumStringConverter.Culture = new CultureInfo(lang);
using (ModelsDBContext ctx = new ModelsDBContext())
{
return(await ctx.Products.ToListAsync());
}
}
/// <summary>
/// Retrieve all existing <see cref="ConceptionDevisWS.Models.User"/>s.
/// </summary>
/// <param name="lang">the culture to get users into (fr-FR or en-US)</param>
/// <returns>a list of users</returns>
public async static Task <IEnumerable <User> > GetAllUsers(string lang)
{
CulturalEnumStringConverter.Culture = new CultureInfo(lang);
using (ModelsDBContext ctx = new ModelsDBContext())
{
return(await ctx.Users.Include(u => u.Clients).ToListAsync <User>());
}
}
private async static Task <User> _findUser(string login)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
return(await ctx.Users.Include(u => u.Clients.Select(c => c.Projects.Select(proj => proj.Products
.Select(prod => prod.Model))))
.FirstOrDefaultAsync(u => u.Login.Equals(login, StringComparison.InvariantCultureIgnoreCase)));
}
}
/// <summary>
/// Retrieve all existing <see cref="ConceptionDevisWS.Models.Client"/>s with their <see cref="ConceptionDevisWS.Models.Project"/>s.
/// </summary>
/// <returns>a list of clients</returns>
public async static Task <IEnumerable <Client> > GetAllClients()
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
return(await ctx.Clients.Include(c => c.Projects)
.Where(c => c.Id != 1)
.ToListAsync <Client>());
}
}
private async static Task <RevokedToken> _findToken(string login)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
RevokedToken revokedToken = await ctx.RevokedTokens.FirstOrDefaultAsync(t => t.Name == login);
return(revokedToken);
}
}
/// <summary>
/// Retrieve a <see cref="ConceptionDevisWS.Models.Client"/>'s <see cref="ConceptionDevisWS.Models.Project"/>s.
/// </summary>
/// <param name="clientId">the client's identity</param>
/// <param name="lang">the culture to get projects into (fr-FR or en-US)</param>
/// <returns>a list of projects</returns>
/// <exception cref="HttpResponseException">In case something went wrong (for example when the given client doesn't exist).</exception>
public async static Task <IEnumerable <Project> > GetClientProjects(int clientId, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Client seekedClient = await _searchClient(clientId, lang);
return(seekedClient.Projects);
}
}
/// <summary>
/// Retrieve a given <see cref="ConceptionDevisWS.Models.Range"/>'s <see cref="ConceptionDevisWS.Models.Model"/>s.
/// </summary>
/// <param name="rangeId">the range's identity</param>
/// <param name="lang">the culture to get the models into (fr-FR or en-US)</param>
/// <returns>a list of models</returns>
/// <exception cref="HttpResponseException">In case something went wrong (for example, when the given range does not exists).</exception>
public async static Task <List <Model> > GetRangeModels(int rangeId, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Range seekedRange = await _searchRange(rangeId, lang);
return(seekedRange.Models);
}
}
/// <summary>
/// Remove the given module from storage.
/// </summary>
/// <param name="id">the module's identity</param>
/// <exception cref="HttpResponseException">In case something went wront (for example, the given module is not found).</exception>
public async static Task RemoveModule(int id)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Module module = await GetModule(id, "fr-FR");
ctx.Entry(module).State = EntityState.Deleted;
await ctx.SaveChangesAsync();
}
}
/// <summary>
/// Remove the given <see cref="ConceptionDevisWS.Models.Project"/> from storage.
/// </summary>
/// <param name="clientId">the client's identity</param>
/// <param name="id">the project's identity</param>
/// <exception cref="HttpResponseException">In case either the client or project doesn't exist.</exception>
public async static Task RemoveProject(int clientId, int id)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Project seekedProject = await _searchClientProject(clientId, id, "fr-FR");
ctx.Entry(seekedProject).State = EntityState.Deleted;
await ctx.SaveChangesAsync();
}
}
/// <summary>
/// Remove the given <see cref="ConceptionDevisWS.Models.Model"/> from storage.
/// </summary>
/// <param name="rangeId">the range'es identity</param>
/// <param name="id">the model's identity</param>
/// <exception cref="HttpResponseException">In case something went wrong (for example, when the requested range or model does not exists).</exception>
public async static Task RemoveModel(int rangeId, int id)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Model seekedModel = await _searchRangeModel(rangeId, id, "fr-FR");
ctx.Entry(seekedModel).State = EntityState.Deleted;
await ctx.SaveChangesAsync();
}
}
/// <summary>
/// Remove an <see cref="ConceptionDevisWS.Models.User"/>.
/// </summary>
/// <param name="id">the user's identity</param>
/// <exception cref="HttpResponseException">In case something went wront (for example the requested user doesn't exist).</exception>
public async static Task RemoveUser(int id)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
User seekedUser = await GetUser(id, "fr-FR");
ctx.Entry(seekedUser).State = EntityState.Deleted;
await ctx.SaveChangesAsync();
}
}
/// <summary>
/// Logs a <see cref="ConceptionDevisWS.Models.User"/> out.
/// </summary>
/// <param name="principal">the user's security identity</param>
/// <remarks>
/// This is not fully \htmlonly <accronym title="REpresentational State Transfer">REST</accronym>\endhtmlonly compliant, but it's usual.
/// </remarks>
public async static Task Logout(IPrincipal principal)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
RevokedToken revokedToken = new RevokedToken {
Name = principal.Identity.Name
};
ctx.RevokedTokens.Add(revokedToken);
await ctx.SaveChangesAsync();
}
}
/// <summary>
/// Retrieve all existing <see cref="ConceptionDevisWS.Models.Range"/>s with their <see cref="ConceptionDevisWS.Models.Model"/>s.
/// </summary>
/// <param name="lang">the language to get ranges for (fr-FR or en-US)</param>
/// <returns>a list of ranges</returns>
public async static Task <IEnumerable <Range> > GetAllRanges(string lang)
{
CulturalEnumStringConverter.Culture = new CultureInfo(lang);
using (ModelsDBContext ctx = new ModelsDBContext())
{
return(await ctx.Ranges.Include(
r => r.Models)
.Include(r => r.Models.Select(m => m.Modules.Select(mod => mod.Components)))
.ToListAsync <Range>());
}
}
/// <summary>
/// Remove the given <see cref="ConceptionDevisWS.Models.Range"/> and its <see cref="ConceptionDevisWS.Models.Model"/>s from storage.
/// </summary>
/// <param name="id">the range's identity</param>
/// <exception cref="HttpResponseException">In case something went wrong (for example, when the requested range does not exists).</exception>
public async static Task RemoveRange(int id)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Range seekedRange = await GetRange(id, "fr-FR");
ctx.Entry(seekedRange).State = EntityState.Deleted;
ctx.Entry(seekedRange).Collection(r => r.Models).EntityEntry.State = EntityState.Deleted;
await ctx.SaveChangesAsync();
}
}
/// <summary>
/// Update completely a given <see cref="ConceptionDevisWS.Models.Project"/>.
/// </summary>
/// <param name="clientId">the client's identity</param>
/// <param name="id">the project's identity</param>
/// <param name="newProject">the updated project </param>
/// <param name="lang">the culture to update the project into (fr-FR or en-US)</param>
/// <returns>the updated project</returns>
/// <exception cref="HttpResponseException">In case either the client or project doesn't exist.</exception>
public async static Task <Project> UpdateProject(int clientId, int id, Project newProject, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
if (newProject == null || newProject.Name == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
if (newProject.Client == null)
{
newProject.Client = new Client();
}
newProject.Client.Id = clientId;
Project seekedProject = await _searchClientProject(clientId, id, lang);
ctx.Entry(seekedProject).State = EntityState.Modified;
ctx.Entry(seekedProject).Collection(p => p.Products).EntityEntry.State = EntityState.Modified;
List <Expression <Func <Client, object> > > clientInfosExpr = new List <Expression <Func <Client, object> > > {
};
await ServiceHelper <Project> .SetSingleNavigationProperty <Client>(newProject, seekedProject, ctx, p => p.Client, _getCtxClients, clientInfosExpr, _setClient);
await ServiceHelper <Project> .UpdateNavigationProperty <Product>(newProject, seekedProject, ctx, _getProducts, _getCtxProducts);
foreach (Product newProduct in newProject.Products)
{
Product currentProduct = seekedProject.Products.Find(prod => prod.Id == newProduct.Id);
if (currentProduct != null)
{
currentProduct.UpdateNonComposableProperties(newProduct);
}
}
seekedProject.UpdateNonComposedPropertiesFrom(newProject);
bool updateSuccess = false;
do
{
try
{
await ctx.SaveChangesAsync();
updateSuccess = true;
} catch (DbUpdateConcurrencyException dbuce)
{
DbEntityEntry entry = dbuce.Entries.Single();
entry.OriginalValues.SetValues(await entry.GetDatabaseValuesAsync());
}
} while (!updateSuccess);
return(seekedProject);
}
}
private async static Task _removeLogout(string login)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
RevokedToken seekedToken = await _findToken(login);
if (seekedToken != null)
{
ctx.Entry(seekedToken).State = EntityState.Deleted;
await ctx.SaveChangesAsync();
}
}
}
public async static Task RemoveProduct(int id)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Product seekedProduct = await GetProduct(id, "fr-FR");
ctx.Entry(seekedProduct).State = EntityState.Deleted;
ctx.Entry(seekedProduct).Reference(p => p.Model).EntityEntry.State = EntityState.Unchanged;
// deletes the relation between the removed product and its model
ctx.Entry(seekedProduct).Collection(p => new Model[] { p.Model }).EntityEntry.State = EntityState.Deleted;
await ctx.SaveChangesAsync();
}
}
