I wanted to apologise off the bat for asking a question with very little prior information to go on, but im at a loss as to how to even start.
I need to create a list of SKUs based on a preset grouping of SKUs that already exists its like a combination table, or iteration table.
However doing this manually is a ridiculous task and I could find no Javascript site that would allow me to do it as required.
Using PHP Classes i thought it would be a much more efficient way to achieve the goal.
AIM: The target item will consist of 5 or so TYPES of items. For each TYPE there is approximately 15-20 exact codes it could consist of.
For example TYPE 1 could be Apple, Pear, Orange, Pineapple. Etc. TYPE 2 could be Red,Green,Blue,Black. Etc
I need to be able to input a list of Variants for each TYPE and have it concatenate the Variants in every possible iteration of an item that could exist.
I am aware this would create 10s of thousands of (in this case) SKUs.
The problem i encounter is when creating the iterations the types always duplicate. Furthermore there are exceptions to this rule, for example Variant Apple could never be with Variant Black. So those types would never be found in the same concatenated code.
Im sure that for someone out their this is really very simple basic grouping and class configuration. So I very much appreciate any help that anyone might have for this.
Many Thanks - Lewis
The following is something VERY QUICK and VERY DIRTY, I've just thrown it together to give you a helping hand and something to start with... so please not "ah thats rubbish code comments" ;)
<?php
class SkuGenerator2000
{
public function generate($productId, array $variants, array $disallow)
{
// First lets get all of the different permutations = cartesian product
$permutations = $this->permutate($variants);
// Now lets get rid of the pesky combinations we don't want
$filtered = $this->squelch($permutations, $disallow);
// Finally we can generate some SKU codes using the $productId as the prefix
// this assumes you want to reuse this code for different products
$skus = $this->skuify($productId, $filtered);
return $skus;
}
public function permutate(array $variants)
{
// filter out empty values
// This is the cartesian product code
$input = array_filter($variants);
$result = array(array());
foreach ($input as $key => $values) {
$append = array();
foreach($result as $product) {
foreach($values as $item) {
$product[$key] = $item;
$append[] = $product;
}
}
$result = $append;
}
return $result;
}
public function squelch(array $permutations, array $rules)
{
// We need to loop over the differnt permutations we have generated
foreach ($permutations as $per => $values) {
$valid = true;
$test = array();
// Using the values, we build up a comparison array to use against the rules
foreach ($values as $id => $val) {
// Add the KEY from the value to the test array, we're trying to make an
// array which is the same as our rule
$test[$id] = $val[0];
}
// Now lets check all of our rules against our new test array
foreach ($rules as $rule) {
// We use array_diff to get an array of differences, then count this array
// if the count is zero, then there are no differences and our test matches
// the rule exactly, which means our permutation is invalid
if (count(array_diff($rule, $test)) <= 0) {
$valid = false;
}
}
// If we found it was an invalid permutation, we need to remove it from our data
if (!$valid) {
unset($permutations[$per]);
}
}
// return the permutations, with the bad combinations removed
return $permutations;
}
public function skuify($productId, array $variants)
{
// Lets create a new array to store our codes
$skus = array();
// For each of the permutations we generated
foreach ($variants as $variant) {
$ids = array();
// Get the ids (which are the first values) and add them to an array
foreach ($variant as $vals) {
$ids[] = $vals[0];
}
// Now we create our SKU code using the ids we got from our values. First lets use the
// product id as our prefix, implode will join all the values in our array together using
// the separator argument givem `-`. This creates our new SKU key, and we store the original
// variant as its value
$skus[$productId . '-' . implode('-', $ids)] = $variant;
// The bit above can be modified to generate the skues in a different way. It's a case of
// dumping out our variant data and trying to figure what you want to do with it.
}
// finall we return our skus
return $skus;
}
}
// Possible variants
$variants = array(
'brand' => array(
// the first value in our array is our SKU identifier, this will be used to create our unqiue SKU code
// the second value is a nice name, description if you will
array('AP', 'Apple'),
array('BA', 'Banana'),
array('PE', 'Pear'),
),
'color' => array(
array('RE', 'Red'),
array('GR', 'Green'),
array('BL', 'Blue'),
),
);
// Rules for combinations I dont want
$disallow = array(
array('brand' => 'AP', 'color' => 'GR'), // No green apples
array('brand' => 'AP', 'color' => 'RE'), // No red apples
array('brand' => 'PE', 'color' => 'BL'), // No blue pears
);
// Create new class
$skuGenerator = new SkuGenerator2000();
// Get me my skus!
$skus = $skuGenerator->generate('PHONE1', $variants, $disallow);
var_dump(array_keys($skus)); // Dump just the skus
// separate our data
echo "
";
// Now dump the entire result!
var_dump($skus); // Dump it all