/// <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);
}
}
/// <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>
/// 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 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>
/// 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);
}
}
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();
}
}
/// <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.Model"/>.
/// </summary>
/// <param name="rangeId">the range's identity</param>
/// <param name="id">the model's identity</param>
/// <param name="newModel">the updated model to store</param>
/// <param name="lang">the culture to update this range into (fr-FR or en-US)</param>
/// <returns>the updated model</returns>
/// <exception cref="HttpResponseException">In case something went wrong (for example, when the requested range or model does not exists).</exception>
public async static Task <Model> UpdateModel(int rangeId, int id, Model newModel, string lang)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
if (newModel.Range == null)
{
newModel.Range = new Range();
}
newModel.Range.Id = rangeId;
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);
}
Model seekedModel = await _searchRangeModel(rangeId, id, lang);
ctx.Entry(seekedModel).State = EntityState.Modified;
ctx.Entry(seekedModel).Collection(m => m.Modules).EntityEntry.State = EntityState.Modified;
List <Expression <Func <Range, object> > > modelsExpr = new List <Expression <Func <Range, object> > >();
await ServiceHelper <Model> .SetSingleNavigationProperty <Range>(newModel, seekedModel, ctx, m => m.Range, _getCtxRanges, modelsExpr, _setRange);
await ServiceHelper <Model> .UpdateNavigationProperty <Module>(newModel, seekedModel, ctx, _getModules, _getCtxModules);
seekedModel.UpdateNonComposedPropertiesFrom(newModel);
bool updateSuccess = true;
do
{
try
{
await ctx.SaveChangesAsync();
updateSuccess = true;
} catch (DbUpdateConcurrencyException dbuce)
{
DbEntityEntry entry = dbuce.Entries.Single();
entry.OriginalValues.SetValues(await entry.GetDatabaseValuesAsync());
}
} while (!updateSuccess);
return(seekedModel);
}
}
public async static Task <Product> UpdateProduct(int id, Product newProduct, string lang)
{
if (newProduct == null || newProduct.Name == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
using (ModelsDBContext ctx = new ModelsDBContext())
{
Product seekedProduct = await GetProduct(id, lang);
ctx.Entry(seekedProduct).State = EntityState.Modified;
ctx.Entry(seekedProduct).Reference(p => p.Model).EntityEntry.State = EntityState.Unchanged;
seekedProduct.UpdateNonComposableProperties(newProduct);
await ctx.SaveChangesAsync();
return(newProduct);
}
}
/// <summary>
/// Remove the given <see cref="ConceptionDevisWS.Models.Client"/> from storage.
/// </summary>
/// <param name="id">the client's identity</param>
/// <returns>The request's HttpStatusCode</returns>
/// <exception cref="HttpResponseException">In case something went wrong (for example, when the requested client does not exists).</exception>
public async static Task RemoveClient(int id)
{
using (ModelsDBContext ctx = new ModelsDBContext())
{
Client seekedClient = await GetClient(id);
Client maderaClient = await ctx.Clients.FindAsync(1);
IEnumerable <Task> tasks = seekedClient.Projects.Select(p => {
return(ProjectService.SpecialUpdateProject(p.Client.Id, maderaClient.Id, p.Id, p, "fr-FR"));
});
await Task.WhenAll(tasks);
ctx.Entry(seekedClient).Collection(c => c.Projects).EntityEntry.State = EntityState.Modified;
seekedClient.Projects.Clear();
ctx.Entry(seekedClient).State = EntityState.Deleted;
await ctx.SaveChangesAsync();
}
}
/// <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.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 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 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();
}
}
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();
}
}
}